#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstring>
#include <map>
#include <queue>
using namespace std;
typedef long long LL ;
typedef pair<int,int> pii ;
#define X first
#define Y second
#define root 1,n,1
#define lr rt<<1
#define rr rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
const int N = 200010;
const int mod = 10007;

int sum1[N<<2] , sum2[N<<2] , sum3[N<<2] , lazy1[N<<2] , lazy2[N<<2] , lazy3[N<<2];
int n , m ;
void build( int l , int r , int rt ) {
    sum1[rt] = sum2[rt] = sum3[rt] = 0 ;
    lazy1[rt] = lazy3[rt] = 0 ;   // add  and clean
    lazy2[rt] = 1 ;                 // muti
    if( l == r ) return ;
    int mid = (l+r)>>1;
    build(lson) , build(rson);
}

void Up( int rt ) {
    sum1[rt] = ( sum1[lr] + sum1[rr] ) % mod ;
    sum2[rt] = ( sum2[lr] + sum2[rr] ) % mod ;
    sum3[rt] = ( sum3[lr] + sum3[rr] ) % mod ;
}

void Down( int l , int r , int rt ) {
    if( l == r ) return ;
    int mid = (l+r)>>1;
    if( lazy3[rt] != 0 ) {
        lazy3[lr] = lazy3[rr] = lazy3[rt] ;
        lazy1[lr] = lazy1[rr] = 0 ;
        lazy2[lr] = lazy2[rr] = 1 ;
        sum1[lr] = ( mid - l + 1 ) * lazy3[rt] % mod ;
        sum2[lr] = ( mid - l + 1 ) * lazy3[rt] % mod * lazy3[rt] % mod ;
        sum3[lr] = ( mid - l + 1 ) * lazy3[rt] % mod * lazy3[rt] % mod * lazy3[rt] % mod ;
        sum1[rr] = ( r - mid ) * lazy3[rt] % mod ;
        sum2[rr] = ( r - mid ) * lazy3[rt] % mod * lazy3[rt] % mod ;
        sum3[rr] = ( r - mid ) * lazy3[rt] % mod * lazy3[rt] % mod * lazy3[rt] % mod ;
        lazy3[rt] = 0 ;
    }
    if( lazy1[rt] != 0 || lazy2[rt] != 1 ) {
        lazy1[lr] = ( lazy1[lr] * lazy2[rt] % mod + lazy1[rt] ) % mod ;
        lazy2[lr] = lazy2[lr] * lazy2[rt] % mod ;
        sum3[lr] = ( lazy2[rt] * lazy2[rt] % mod * lazy2[rt] % mod * sum3[lr] % mod
                    + 3 * lazy2[rt] % mod * lazy2[rt] % mod * sum2[lr] % mod * lazy1[rt] % mod +
                    + 3 * lazy2[rt] % mod * sum1[lr] % mod * lazy1[rt] % mod * lazy1[rt] % mod
                    + ( mid - l + 1 ) * lazy1[rt] % mod * lazy1[rt] % mod * lazy1[rt] % mod
                    ) % mod ;
        sum2[lr] = ( lazy2[rt] * lazy2[rt] % mod * sum2[lr] % mod
                    + 2 * lazy1[rt] % mod * lazy2[rt] % mod * sum1[lr] % mod
                    + ( mid - l + 1 ) * lazy1[rt] % mod * lazy1[rt] % mod ) % mod ;
        sum1[lr] = ( sum1[lr] * lazy2[rt] % mod + lazy1[rt]*( mid - l + 1 ) % mod ) % mod;


        lazy1[rr] = ( lazy1[rr] * lazy2[rt] % mod + lazy1[rt] ) % mod ;
        lazy2[rr] = lazy2[rr] * lazy2[rt] % mod ;
        sum3[rr] = ( lazy2[rt] * lazy2[rt] % mod * lazy2[rt] % mod * sum3[rr] % mod
                    + 3 * lazy2[rt] % mod * lazy2[rt] % mod * sum2[rr] % mod * lazy1[rt] % mod +
                    + 3 * lazy2[rt] % mod * sum1[rr] % mod * lazy1[rt] % mod * lazy1[rt] % mod
                    + ( r - mid  ) * lazy1[rt] % mod * lazy1[rt] % mod * lazy1[rt] % mod
                    ) % mod ;
        sum2[rr] = ( lazy2[rt] * lazy2[rt] % mod * sum2[rr] % mod
                    + 2 * lazy1[rt] % mod * lazy2[rt] % mod * sum1[rr] % mod
                    + ( r - mid ) * lazy1[rt] % mod * lazy1[rt] % mod ) % mod ;
        sum1[rr] = ( sum1[rr] * lazy2[rt] % mod + lazy1[rt]*( r - mid ) % mod ) % mod;
        lazy1[rt] = 0;  lazy2[rt] = 1;
        }
}

void update( int l , int r , int rt , int L , int R , int c , int op ) {
    if( l == L && r == R ) {                // suppose lazy1 = lazy2 = 0 ; op1
        c %= mod ;
        if( op == 1 ) {
            lazy1[rt] = ( c + lazy1[rt] ) % mod;
            sum3[rt] = ( sum3[rt]
                       + 3 * sum2[rt] % mod * c % mod
                       + 3 * sum1[rt] % mod * c % mod * c % mod
                       + c * c % mod * c % mod * ( r - l + 1 ) % mod
                       ) % mod;
            sum2[rt] = ( sum2[rt]
                        + 2 * sum1[rt] % mod * c % mod
                        + c * c % mod * ( r - l + 1 ) % mod
                        ) % mod ;
            sum1[rt] = ( sum1[rt] + ( r - l + 1 ) * c % mod ) % mod;
        }
        else if( op == 2 ) {
            lazy1[rt] = lazy1[rt] * c % mod ;
            lazy2[rt] = lazy2[rt] * c % mod ;
            sum1[rt] = sum1[rt] * c % mod ;
            sum2[rt] = sum2[rt] * c % mod * c % mod ;
            sum3[rt] = sum3[rt] * c % mod * c % mod * c % mod ;
        }
        else {
            lazy1[rt] = 0  ; lazy2[rt] = 1 ; lazy3[rt] = c % mod ;
            sum1[rt] = (r-l+1) * c % mod ;
            sum2[rt] = (r-l+1) * c % mod * c % mod;
            sum3[rt] = (r-l+1) * c % mod * c % mod *c % mod;
        }
        return ;
    }
    Down(l,r,rt);
    int mid = (l+r)>>1;
    if( R <= mid ) update(lson,L,R,c,op);
    else if( L > mid ) update(rson,L,R,c,op);
    else update(lson,L,mid,c,op),update(rson,mid+1,R,c,op);
    Up(rt);
}

int query( int l , int r , int rt , int L , int R , int c ) {
    if( l == L && r == R ) {
        if( c == 1 ) return sum1[rt] ;
        else if( c == 2 ) return sum2[rt];
        else return sum3[rt];
    }
    Down(l,r,rt);
    int mid = (l+r)>>1;
    if( R <= mid ) return query(lson,L,R,c);
    else if( L > mid ) return query(rson,L,R,c);
    else return (query(lson,L,mid,c)+query(rson,mid+1,R,c))%mod;
}

int main()
{
    #ifdef LOCAL
       freopen("in.txt","r",stdin);
       //freopen("out.txt","w",stdout);
    #endif // LOCAL
    while( ~scanf("%d%d",&n,&m ) ) {
        if( n == 0 && m == 0 ) break ;
        build( root ) ;
        int op , x , y , c ;
        while( m-- ) {
            scanf("%d%d%d%d",&op,&x,&y,&c);
            if( op != 4 ) update(root,x,y,c,op);
            else printf("%d\n",query(root,x,y,c));
        }
    }
}