!

#include <bits/stdc++.h>
#define ll                                      long long
#define fi                                      freopen("in.txt", "r", stdin)
#define fo                                      freopen("out.txt", "w", stdout)
#define m0(a) memset(a , 0 , sizeof(a))
#define m1(a) memset(a , -1 , sizeof(a))

#define mx 100009
using namespace std;
ll N, i, j ;

struct node
{
    ll sum   ;
    ll prop ;
};

typedef struct node node ;

node seg[mx*5] ;

void pushUp(ll sp)
{
    seg[sp].sum = seg[2*sp+1].sum + seg[2*sp+2].sum ;
}


void pushdown(ll lo, ll hi, ll sp)
{
    if(seg[sp].prop == -1)
    {
        return ;
    }

    ll mid ;
    mid = (lo+hi) / 2 ;

    ll l, r ;

    l = mid - lo + 1 ;
    r = hi - (mid + 1) + 1 ;


    seg[2*sp+1].prop = seg[sp].prop ;
    seg[2*sp+1].sum = seg[sp].prop * l ; // what is the point of update it ..... you have already put it in your lazy
    seg[2*sp+2].prop = seg[sp].prop ;
    seg[2*sp+2].sum = seg[sp].prop * r ; // same problem

    seg[sp].prop = -1 ;
    return ;
}

// what is the point of returning a node????
node update(ll lo, ll hi, ll sp, ll x)
{
    //you have to push down first cause what if there is a update but you return

    if(lo > j || hi < i )
    {
        return node();
    }
    if(lo >= i && hi <= j)
    {
        ll n ;
        n = (hi - lo + 1) ;

        seg[sp].prop = x ;
        seg[sp].sum = n * x ;
        //what about lazy tree you don't update it
        //you just update your current node
        //also you dont clear your current lazy
        return seg[sp] ;
    }

    pushdown(lo, hi, sp) ; // this potion going in top

    ll mid ;
    mid = (lo+hi) / 2 ;


    update(lo, mid, 2*sp+1, x) ;
    update(mid+1, hi, 2*sp+2, x) ;

    seg[sp].sum = seg[2*sp+1].sum + seg[2*sp+2].sum ;


    pushUp(sp) ;
    return seg[sp] ;
}


ll query(ll lo, ll hi, ll sp)
{
    //you have to push down first cause what if there is a update but you return

    if(lo > j || hi < i)
    {
        return 0 ;
    }
    if(lo >= i && hi <= j)
    {
        ll n ;
        n = hi - lo + 1 ;
        return seg[sp].sum ;
    }

    pushdown(lo, hi, sp) ; // same problem

    ll mid ;
    mid = (lo+hi) / 2 ;

    ll r = 0  ;
    r += query(lo, mid, 2*sp+1) ;
    r += query(mid+1, hi, 2*sp+2) ;

    return r ;
}

//i think its ok ... but you can double check it
ll gcd(ll a, ll b)
{
    if(a < b)
    {
        swap(a,b) ;
    }
    ll r, d ;
    while(b != 0)
    {
        r = a % b ;
        a = b ;
        b = r ;
    }
    return a ;
}

int main()
{
//    fi ;
//    fo ;
    ll T ;
    scanf("%lld",&T);
    ll t = 0 ;
    ll q, c ;
    while(T--)
    {
        for(ll k = 0 ; k < mx*5 ; k++)
        {
            seg[k].sum = 0  ;
            seg[k].prop = -1 ;
        }

        t++ ;
        scanf("%lld %lld",&N, &q) ;
//        cout << q << endl ;
        printf("Case %lld:\n",t) ;
        while(q--)
        {
            scanf("%lld",&c) ;
            if(c==2)
            {
                scanf("%lld %lld",&i, &j) ;
                ll ans, n ;
                n = j - i + 1 ;
                ans = query(0, N-1, 0) ;
//                cout << ans << endl ;
                if(ans % n == 0)
                {
                    printf("%lld\n",ans / n) ;
                }
                else
                {
                    ll g = gcd(ans, n) ;
                    ll nom, denom ;
                    nom = ans /  g ;
                    denom = n / g ;
                    printf("%lld/%lld\n",nom, denom) ;
                }
//                if(q!=0)
//                {
//                    printf("\n") ;
//                }
            }
            else if(c==1)
            {
                ll v ;
                scanf("%lld %lld %lld", &i, &j, &v) ;
                update(0, N-1, 0, v) ;
            }
        }
    }

    return 0 ;
}