题意：有四种操作

1，  区间 [l, r] 的值都加上 C

2，  区间 [l, r] 的值都乘上 C

3，  区间 [l, r] 的值都变为C

4，  求区间 [l, r]所有数的p次方的和

分析：是比较麻烦的区间操作，设计四种操作，更新的时候无法更新到底部，不过仔细思考可以想到这都是对区间进行的操作，所以会造成一部分的区间值相等，所以只需要更新到相等区间部分就行了，而且注意有第三种操作的时候，第二和第一种操作可以去掉，操作的优先性是3>2>1,。

WA了一次，因为操作三进行的的时候没有把前两种操作去除

*************************************************************************

#include<algorithm>

#include<stdio.h>

using namespace std;

#define lson u<<1

#define rson u<<1|1

const int MAXN = 1e5+5;

const int mod = 1e4+7;

struct node

{///num表示这个区间的数（区间里面的值都相等，不相等时候为0），mul记录乘的次数，add表示需要加的数

    int l, r, num, mul, add, cover;///cover 等于0的时候表示区间的值不相同，等于1表示区间进行覆盖操作，等于2表示区间的值相同

    int m(){return (l+r)>>1;}

    int len(){return r-l+1;}

}a[MAXN<<2];

void Up(int u)

{

    if( a[lson].cover && a[rson].cover )

    if( a[lson].num == a[rson].num )

        a[u].num = a[lson].num, a[u].cover = 2;

}

void Down(int u)

{

    if(a[u].l != a[u].r)

    {

        if( a[u].cover == 1 )

        {

            a[lson].cover = a[rson].cover = 1;

            a[lson].num = a[rson].num = a[u].num;

            a[lson].add = a[rson].add = 0;

            a[lson].mul = a[rson].mul = 1;

            a[u].cover = 2, a[u].mul = 1, a[u].add = 0;

        }

        if( a[u].mul > 1 )

        {

            (a[lson].mul *= a[u].mul)%=mod, (a[rson].mul *= a[u].mul)%=mod;

            (a[lson].num *= a[u].mul)%=mod, (a[rson].num *= a[u].mul)%=mod;

            (a[lson].add *= a[u].mul)%=mod, (a[rson].add *= a[u].mul)%=mod;

            a[u].mul = 1;

        }

        if( a[u].add )

        {

            (a[lson].add += a[u].add)%=mod, (a[rson].add += a[u].add)%=mod;

            (a[lson].num += a[u].add)%=mod, (a[rson].num += a[u].add)%=mod;

            a[u].add = 0;

        }

    }

}

void Build(int u, int l, int r)

{

    a[u].add = 0, a[u].cover = 2, a[u].mul = 1;

    a[u].num = 0, a[u].l = l, a[u].r = r;

    if(l == r)

        return ;

    Build(lson, l, a[u].m());

    Build(rson, a[u].m()+1, r);

}

void Insert(int u, int l, int r, int op, int val)

{

    if(a[u].l == l && a[u].r == r && a[u].cover)

    {

        if(op == 3)

            a[u].add=0, a[u].cover = 1, a[u].mul = 1, a[u].num = val;

        else if(op == 2)

            (a[u].mul *= val)%=mod, (a[u].add *= val)%=mod, (a[u].num *= val)%=mod;

        else

            (a[u].add += val)%=mod, (a[u].num += val)%=mod;

        return ;

    }

    Down(u); a[u].cover = 0;

    if(r <= a[u].m())

        Insert(lson, l, r, op, val);

    else if(l > a[u].m())

        Insert(rson, l, r, op, val);

    else

    {

        Insert(lson, l, a[u].m(), op, val);

        Insert(rson, a[u].m()+1, r, op, val);

    }

    Up(u);

}

int  Query(int u, int l, int r, int p)

{

    if(a[u].l == l && a[u].r == r && a[u].cover)

    {

        int ans = 1;

        while(p--) (ans *= a[u].num)%=mod;

        ans = (ans * a[u].len())%mod;

        return ans;

    }

    Down(u);

    if(r <= a[u].m())

        return Query(lson, l, r, p);

    else if(l > a[u].m())

        return Query(rson, l, r, p);

    else

    {

        int lsum = Query(lson, l, a[u].m(), p);

        int rsum = Query(rson, a[u].m()+1, r, p);

        return (lsum+rsum) % mod;

    }

}

int  main()

{

    int N, M;

    while(scanf("%d%d", &N, &M), N+M)

    {

        int u, v, op, c;

        Build(1, 1, N);

        while(M--)

        {

            scanf("%d%d%d%d", &op, &u, &v, &c);

            if(op != 4)

                Insert(1, u, v, op, c);

            else

                printf("%d\n", Query(1, u, v, c));

        }

    }

    return 0;

}