#include<iostream>

using namespace std;

const int N = 1e6 + 10;

typedef long long ll;

ll a[N],b[N], d[N], primes[N],n,m,cnt,res;
bool vis[N];
struct node {
    ll l;
    ll r;
    ll val;
    ll mx;
    ll flag;
}tr[N*4];

void get_primes(ll mx)
{
    d[0] = 0;
    d[1] = 1;
    for (ll i = 2; i <=mx; i++) {
        if (!vis[i]) primes[++cnt] = i,d[i]=2,b[i]=1;
        for (ll j = 1; j <= cnt&&primes[j]<=mx/i; j++) {
            if (primes[j] * i > mx) break;
            vis[primes[j] * i] = 1;
            if (i % primes[j] != 0) {
                d[i * primes[j]] = d[i] * d[primes[j]];
                b[i * primes[j]] = 1;
            }
            else {
                ll m = i * primes[j];
                b[m] = b[i] + 1;
                d[i * primes[j]] = d[i] / (b[i] + 1) * (b[primes[j]] + b[i] + 1);
                break;
            }
        }
    }
}
void update(ll node)
{
    tr[node].val = tr[node * 2].val + tr[node * 2 + 1].val;
    tr[node].mx = max(tr[node * 2].mx, tr[node * 2 + 1].mx);
}
void down(ll node)
{
    if (tr[node].flag) {
        tr[node * 2].flag += tr[node].flag;
        tr[node * 2+1].flag += tr[node].flag;
        tr[node].flag = 0;
    }
}
void pro(ll i,ll node)
{
    a[i] = d[a[i]];
    tr[node].val = a[i];
}
void build_tree(ll L, ll R,ll node)
{
    tr[node].l = L;
    tr[node].r = R;
    ll mid= L + R >> 1;
    if (L == R) {
        tr[node].val = a[L];
        tr[node].mx = a[L];

        return;
    }
    build_tree(L, mid, node *2);
    build_tree(mid+1, R, node*2+1);
    update(node);
}
void add(ll L, ll R,ll node)
{
    ll l = tr[node].l;
    ll r = tr[node].r;
    ll mid = l + r >> 1;
    if (l >= L && r <= R&& tr[node].mx <= 2) {
        tr[node].flag = 0;
        return;
    }
    if (tr[node].l == tr[node].r) {
        pro(tr[node].l,node);

        return;
    }
    down(node);
    if (L <= mid) add(L, R, node << 1);
    if (R > mid) add(L, R, node << 1 | 1);
    update(node);
}
ll qur(ll L, ll R, ll node)
{
    ll l = tr[node].l;
    ll r = tr[node].r;
    ll mid = l + r >> 1;
    if (l >= L && r <= R) {
        return tr[node].val;
    }
    ll tem = 0;
    down(node);
    if (L <= mid) tem += qur(L, R, node << 1);
    if (r > mid) tem += qur(L, R, node << 1 | 1);

    return tem;
}
int main()
{
    scanf("%lld%lld", &n, &m);
    ll tem = 0;
    for (ll i = 1; i <= n; i++) {
        cin >> a[i];
        tem = max(tem, a[i]);
    }
    get_primes(tem);
    
    build_tree(1, n, 1);
    for (ll i = 1; i <= m; i++) {
        ll op;
        ll x, y;
        scanf("%lld", &op);
        if (op == 1) {
            scanf("%lld%lld", &x, &y);
            add(x, y, 1);
        }
        else if (op == 2) {
            scanf("%lld%lld", &x, &y);
            res = qur(x, y, 1);
            printf("%lld\n", res);
        }
    }

    return 0;
}