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
#include <bits/stdc++.h>
const long long N = 1e6 + 5, MOD = 1e9 + 7, INF = LONG_MAX;
using namespace std;
int dx[] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long n, m, t, a[N], cnt[N];
pair<long long, long long> tree[4 * N];
static void sieve() {
  fill(cnt, cnt + N, 1);
  for (long long i = 2; i < N; ++i) {
    for (long long j = i; j < N; j += i) cnt[j]++;
  }
}
static void build(int v, int l, int r) {
  if (l == r) {
    tree[v] = {a[l], a[l]};
    return;
  }
  int mid = (l + r) / 2;
  build(v * 2, l, mid);
  build(v * 2 + 1, mid + 1, r);
  tree[v] = {tree[v * 2].first + tree[v * 2 + 1].first,
             max(tree[v * 2].second, tree[v * 2 + 1].second)};
}
static void update(int v, int l, int r, int aa, int b) {
  if (r < aa || b < l || tree[v].second <= 2) return;
  if (l == r) {
    a[l] = cnt[a[l]];
    tree[v] = {a[l], a[l]};
    return;
  }
  int mid = (l + r) / 2;
  update(v * 2, l, mid, aa, b);
  update(v * 2 + 1, mid + 1, r, aa, b);
  tree[v] = {tree[v * 2].first + tree[v * 2 + 1].first,
             max(tree[v * 2].second, tree[v * 2 + 1].second)};
}
static long long query(int v, int l, int r, int a, int b) {
  if (r < a || b < l) return 0;
  if (l >= a && b >= r) return tree[v].first;
  int mid = (l + r) / 2;
  return query(v * 2, l, mid, a, b) + query(v * 2 + 1, mid + 1, r, a, b);
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  sieve();
  cin >> n >> t;
  for (int i = 1; i <= n; ++i) cin >> a[i];
  int sz = 1;
  while (sz < n) sz *= 2;
  build(1, 1, sz);
  while (t--) {
    int l, r, type;
    cin >> type >> l >> r;
    if (type == 1)
      update(1, 1, sz, l, r);
    else
      cout << query(1, 1, sz, l, r) << '\n';
  }
  return 0;
}
