Problem: Let D(x) be the number of positive divisors of a positive integer x. For example, D(2) = 2 (2 is divisible by 1 and 2), D(6) = 4 (6 is divisible by 1, 2, 3 and 6).

You are given an array a of n integers. You have to process two types of queries:

  1. REPLACE l r — for every <image> replace ai with D(ai); 
  2. SUM l r — calculate <image>. 



Print the answer for each SUM query.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 3·105) — the number of elements in the array and the number of queries to process, respectively.

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the elements of the array.

Then m lines follow, each containing 3 integers ti, li, ri denoting i-th query. If ti = 1, then i-th query is REPLACE li ri, otherwise it's SUM li ri (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).

There is at least one SUM query.

Output

For each SUM query print the answer to it.

Example

Input

7 6
6 4 1 10 3 2 4
2 1 7
2 4 5
1 3 5
2 4 4
1 5 7
2 1 7


Output

30
13
4
22

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const int N = (int)1e6 + 10;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, m;
long long t[1201201], g[1201201];
long long d[N + 10], a[300300];
vector<int> pr;
int lp[N + 10];
int get(int n) {
  int ans = 1;
  for (int i = lp[n]; n != 1; i = lp[n]) {
    int p = 0;
    while (n % i == 0) {
      p++;
      n /= i;
    }
    ans = ans * (p + 1);
  }
  return ans;
}
void calc() {
  for (int i = 2; i <= N; ++i) {
    if (lp[i] == 0) {
      lp[i] = i;
      pr.push_back(i);
    }
    for (int j = 0; j < pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j) {
      lp[i * pr[j]] = pr[j];
    }
  }
  for (int i = 2; i <= (int)1e6; ++i) {
    d[i] = get(i);
  }
}
void build(int v, int tl, int tr) {
  if (tl == tr) {
    t[v] = a[tl];
    g[v] = a[tl];
    return;
  }
  int mid = (tl + tr) >> 1;
  build(v + v, tl, mid);
  build(v + v + 1, mid + 1, tr);
  t[v] = t[v + v] + t[v + v + 1];
  g[v] = max(g[v + v], g[v + v + 1]);
}
void update(int v, int tl, int tr, int l, int r) {
  if (tr < l || r < tl) return;
  if (l <= tl && tr <= r) {
    if (g[v] <= 2) return;
  }
  if (tl == tr) {
    t[v] = d[t[v]];
    g[v] = d[g[v]];
    return;
  }
  int mid = (tl + tr) >> 1;
  update(v + v, tl, mid, l, r);
  update(v + v + 1, mid + 1, tr, l, r);
  t[v] = t[v + v] + t[v + v + 1];
  g[v] = max(g[v + v], g[v + v + 1]);
}
long long get(int v, int tl, int tr, int l, int r) {
  if (tr < l || r < tl) return 0;
  if (l <= tl && tr <= r) {
    return t[v];
  }
  int mid = (tl + tr) >> 1;
  return get(v + v, tl, mid, l, r) + get(v + v + 1, mid + 1, tr, l, r);
}
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  calc();
  cin >> n >> m;
  for (int i = 1; i <= n; ++i) {
    cin >> a[i];
  }
  build(1, 1, n);
  for (int i = 0; i < m; ++i) {
    int type, l, r;
    cin >> type >> l >> r;
    if (type == 1) {
      update(1, 1, n, l, r);
    } else {
      cout << get(1, 1, n, l, r) << "\n";
    }
  }
}