// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")
#include <bits/stdc++.h>
// #define int long long
#define i64 long long
#define pii pair <int, int> 
using namespace std;
inline int read(void) {
    int x=0,sgn=1; char ch=getchar();
    while(ch<48||57<ch) {if(ch==45)sgn=0;ch=getchar();}
    while(47<ch&&ch<58) {x=x*10+ch-48;   ch=getchar();}
    return sgn? x:-x;
}
void write(int x) {
    if(x<0) putchar('-'),x=-x;
    if(x>9) write(x/10);
    putchar(x%10+'0');
}
/*
    write((Ans%p+p)%p); pls
*/
const int mod=998244353;
const int p=1000000007;
int n,q;
int hed[3003];
int tmp[3003][3003];
struct Node {
    int lnk[4];
    i64 del[4];
    int cur;
    i64 val;
    inline void locate(int x) {
        if(lnk[0]==x) return cur=0,void();
        if(lnk[1]==x) return cur=1,void();
        if(lnk[2]==x) return cur=2,void();
        if(lnk[3]==x) return cur=3,void();
    }
    inline void update(int v,int x=0) {
        x=(x+cur)&3;
        del[x]+=v;
    }
    inline int rotate(int x);
    inline void link(int v,int x);
} nod[9100006];
inline int Node::rotate(int x) {
    x=(x+cur)&3;
    nod[lnk[x]].val=val+del[x];
    return lnk[x];
}
inline void Node::link(int v,int x=0) {
    x=(x+cur)&3;
    lnk[x]=v;
    del[x]=nod[v].val-val;
}
inline void link(int a,int ra,int b) {
    nod[a].link(b,ra);
    nod[b].link(a);
}
int cntnod;
inline void initmat() {
    for(int i=1; i<=n; ++i) {
        int x=i+1,cur=i+1;
        for(int u=1; u<=n; ++u) {
            tmp[i][u]=++cntnod;
            nod[cntnod].val=cur;
            cur=1ll*cur*x%mod;
        }        
    }
    for(int i=1; i<=n; ++i) tmp[i][0]=hed[i]=++cntnod,nod[cntnod].link(tmp[i][1]);
    for(int i=1; i<=n; ++i) tmp[0][i]=++cntnod,nod[cntnod].link(tmp[1][i]);
    for(int i=1; i<=n; ++i) tmp[i][n+1]=++cntnod,nod[cntnod].link(tmp[i][n]);
    for(int i=1; i<=n; ++i) tmp[n+1][i]=++cntnod,nod[cntnod].link(tmp[n][i]);
    for(int i=1; i<=n; ++i) {
        for(int u=1; u<=n; ++u) {
            int k=tmp[i][u];
            nod[k].link(tmp[i+1][u],0);
            nod[k].link(tmp[i][u+1],1);
            nod[k].link(tmp[i-1][u],2);
            nod[k].link(tmp[i][u-1],3);
        }
    }
}
inline void debug() {
    const int N=n+1;
    cerr<<"-------------"<<endl;
    for(int i=0; i<=N; ++i) {
        for(int u=0; u<=N; ++u) {
            // fprintf(stderr,"[%2d|%4d|%d]%c",tmp[i][u],nod[tmp[i][u]].val,nod[tmp[i][u]].cur," \n"[u==N]);
            if(tmp[i][u]) fprintf(stderr,"%d%c",nod[tmp[i][u]].cur," \n"[u==N]);
            else fprintf(stderr," %c"," \n"[u==N]);
        }
    }
}
inline void debugAns() {
    cerr<<"-------------"<<endl;
    for(int i=1; i<=n; ++i) {
        for(int u=1; u<=n; ++u) {
            fprintf(stderr,"%10d%c",nod[tmp[i][u]].val," \n"[u==n]);
        }
    }
}
inline void calcval() {
    for(int i=1; i<=n; ++i) {
        tmp[i][1]=nod[hed[i]].rotate(0);
        nod[tmp[i][1]].locate(hed[i]);
        for(int u=2; u<=n; ++u) {
            tmp[i][u]=nod[tmp[i][u-1]].rotate(2);
            nod[tmp[i][u]].locate(tmp[i][u-1]);
        }
    }
}
inline void locate(int l,int r,int u,int d) {
    tmp[u][1]=nod[hed[u]].rotate(0);
    nod[tmp[u][1]].locate(hed[u]);
    for(int i=1; i<l; ++i) {
        tmp[u][i+1]=nod[tmp[u][i]].rotate(2);
        nod[tmp[u][i+1]].locate(tmp[u][i]);
    }

    for(int i=l; i<r; ++i) {
        tmp[u-1][i]=nod[tmp[u][i]].rotate(3);
        tmp[u][i+1]=nod[tmp[u][i]].rotate(2);
        nod[tmp[u-1][i]].locate(tmp[u][i]);
        nod[tmp[u][i+1]].locate(tmp[u][i]);
    }
    tmp[u-1][r]=nod[tmp[u][r]].rotate(3);
    nod[tmp[u-1][r]].locate(tmp[u][r]);
    (nod[tmp[u][r]].cur+=3)&=3;

    for(int i=u; i<d; ++i) {
        tmp[i][r+1]=nod[tmp[i][r]].rotate(3);
        tmp[i+1][r]=nod[tmp[i][r]].rotate(2);
        nod[tmp[i][r+1]].locate(tmp[i][r]);
        nod[tmp[i+1][r]].locate(tmp[i][r]);
    }
    tmp[d][r+1]=nod[tmp[d][r]].rotate(3);
    nod[tmp[d][r+1]].locate(tmp[d][r]);
    (nod[tmp[d][r]].cur+=3)&=3;

    for(int i=r; i>l; --i) {
        tmp[d+1][i]=nod[tmp[d][i]].rotate(3);
        tmp[d][i-1]=nod[tmp[d][i]].rotate(2);
        nod[tmp[d+1][i]].locate(tmp[d][i]);
        nod[tmp[d][i-1]].locate(tmp[d][i]);
    }
    tmp[d+1][l]=nod[tmp[d][l]].rotate(3);
    nod[tmp[d+1][l]].locate(tmp[d][l]);
    (nod[tmp[d][l]].cur+=3)&=3;

    for(int i=d; i>u; --i) {
        tmp[i][l-1]=nod[tmp[i][l]].rotate(3);
        tmp[i-1][l]=nod[tmp[i][l]].rotate(2);
        nod[tmp[i][l-1]].locate(tmp[i][l]);
        nod[tmp[i-1][l]].locate(tmp[i][l]);
    }
    tmp[u][l-1]=nod[tmp[u][l]].rotate(3);
    nod[tmp[u][l-1]].locate(tmp[u][l]);
    (nod[tmp[u][l]].cur+=3)&=3;
}
signed main() {
    // freopen("localinput","r",stdin);
    // freopen("localoutput","w",stderr);
    n=read(); q=read();
    initmat();
    // calcval();
    // debugAns();
    for(int t=1,op,l,r,u,d,v; t<=q; ++t) {
        // memset(tmp,0,sizeof tmp);
        op=read(); u=read(); l=read(); d=read(); r=read();
        locate(l,r,u,d);
        if(op==1) {
            if(l==r) continue;
            for(int i=l; i<r; ++i) link(tmp[u][i],3,tmp[d-(i-l)][l-1]);
            link(tmp[u][r],0,tmp[u][l-1]);
            for(int i=u; i<d; ++i) link(tmp[i][r],3,tmp[u-1][l+(i-u)]);
            link(tmp[d][r],0,tmp[u-1][r]);
            for(int i=r; i>l; --i) link(tmp[d][i],3,tmp[u+(r-i)][r+1]);
            link(tmp[d][l],0,tmp[d][r+1]);
            for(int i=d; i>u; --i) link(tmp[i][l],3,tmp[d+1][r-(d-i)]);
            link(tmp[u][l],0,tmp[d+1][l]);
        } else {
            v=read();
            for(int i=l; i<=r; ++i) {
                nod[tmp[u-1][i]].update(v);
                nod[tmp[d+1][i]].update(v);
            }
            for(int i=u; i<=d; ++i) {
                nod[tmp[i][l-1]].update(v);
                nod[tmp[i][r+1]].update(v);
            }
            if(l!=r&&u!=d) {
                for(int i=l; i<r; ++i) nod[tmp[u][i]].update(-v,3);
                nod[tmp[u][r]].update(-v);
                for(int i=u; i<d; ++i) nod[tmp[i][r]].update(-v,3);
                nod[tmp[d][r]].update(-v);
                for(int i=r; i>l; --i) nod[tmp[d][i]].update(-v,3);
                nod[tmp[d][l]].update(-v);
                for(int i=d; i>u; --i) nod[tmp[i][l]].update(-v,3);
                nod[tmp[u][l]].update(-v);
            } else if(l==r&&u==d) {
                nod[tmp[u][l]].update(-v);
                nod[tmp[u][l]].update(-v,1);
                nod[tmp[u][l]].update(-v,2);
                nod[tmp[u][l]].update(-v,3);
            } else if(l==r) {
                (nod[tmp[u][l]].cur+=3)&=3;
                for(int i=u; i<=d; ++i) nod[tmp[i][l]].update(-v,3),nod[tmp[i][l]].update(-v,1);
                nod[tmp[u][l]].update(-v);
                nod[tmp[d][l]].update(-v);
            } else {
                for(int i=l; i<=r; ++i) nod[tmp[u][i]].update(-v,3),nod[tmp[u][i]].update(-v,1);
                nod[tmp[u][l]].update(-v);
                nod[tmp[u][r]].update(-v);
            }
        }
        // calcval();
        // debugAns();
    }
    calcval();
    // debugAns();
    i64 Ans=0;
    const int base=12345;
    for(int i=n; i>=1; --i) {
        for(int u=n; u>=1; --u) {
            Ans=(Ans+nod[tmp[i][u]].val)%p*base%p;
        }
    }
    write(Ans); puts("");
    // fprintf(stderr,"%.4lf\n",1.0*clock()/CLOCKS_PER_SEC);
    return 0;
}