#include<iostream>
#include<vector>
#include<array>
#include<queue>
#include<cmath>
#include<atcoder/all>

using namespace std;
using namespace atcoder;
#define overload4(_1,_2,_3,_4,name,...) name

#define rep1(i,n) for (int i = 0; i < (n); ++i)
#define rep2(i,m,n) for (int i = (m); i < (n); ++i)
#define rep3(i,m,n,k) for (int i = (m); i < (n); i += (k))

#define rep(...) overload4(__VA_ARGS__, rep3, rep2, rep1)(__VA_ARGS__)

#define inf 1000000000

vector<pair<int,int>> dij = {{0,1}, {1,0}, {0,-1}, {-1,0}};

using mint = modint998244353;
int isqrt(int n){
    double x=sqrt(n);
    int ans=(int)x;
    while ((ans+1)*(ans+1)<=n){
        ans++;
    }
    return ans;
};
struct S{
    int cnt_0;
    int cnt_1;
    array<int,5> fi;
};

S op(S x,S y){
    array<int,5> ans;
    rep (i,5){
        ans[i]=x.fi[i]+y.fi[i];
    }
    return S{x.cnt_0+y.cnt_0,x.cnt_1+y.cnt_1,ans};
};

S conv(int x){
    if (x==0){
        return S{1,0,{0,0,0,0,0}};
    } else {
        array<int,5> ans;
        ans[0]=x;
        rep(i,1,5){
            ans[i]=isqrt(ans[i-1]);
        }
        return S{1,1,ans};
    }
};

S rot(S x){
    array<int,5> ans;
    rep(i,4){
        ans[i]=x.fi[i+1];
    }
    ans[4]=x.cnt_1;
    return S{x.cnt_0,x.cnt_1,ans};
};

S mapping(int f,S x){
    if (f==-inf){
        return x;
    } else if (f<0) {
        S now=x;
        rep (i,-f){
            now=rot(now);
        }
        return now;
    } else {
        S ans=conv(f);
        array<int,5> final;
        rep(i,5){
            final[i]=ans.fi[i]*x.cnt_0;
        }
        return S{ans.cnt_0*x.cnt_0,ans.cnt_1*x.cnt_0,final};
    }
};

int composition(int f,int g){
    if (f==-inf){
        return g;
    } else if (g==-inf){
        return f;
    } else if (f>=0){
        return f;
    } else if (g>=0){
        return mapping(f,conv(g)).fi[0];
    } else {
        return f+g;
    }
};

S e(){
    return S{0,0,{0,0,0,0,0}};
}

int id(){
    return -inf;
};

int main(){
    int n,q;
    cin>>n>>q;
    vector<S> a(n);
    rep(_,n){
        int i;
        cin>>i;
        a[_]=conv(i);
    }
    lazy_segtree<S,op,e,int,mapping,composition,id> seg(a);
    rep(_,q){
        int t,l,r;
        cin>>t>>l>>r;
        if (t==0){
            cout<<seg.prod(l,r).fi[0]<<endl;
        } else if (t==1){
            int x;
            cin>>x;
            seg.apply(l,r,x);
        } else {
            seg.apply(l,r,-1);
        }
    }
}