Egor likes math, and not so long ago he got the highest degree of recognition in the math community — Egor became a red mathematician. In this regard, Sasha decided to congratulate Egor and give him a math test as a present. This test contains an array a of integers of length n and exactly q queries. Queries were of three types: 

  1. "1 l r x" — multiply each number on the range from l to r by x. 
  2. "2 p x" — divide the number at the position p by x (divisibility guaranteed). 
  3. "3 l r" — find the sum of all elements on the range from l to r. 



The sum can be big, so Sasha asked Egor to calculate the sum modulo some integer mod. 

But since Egor is a red mathematician, he doesn't have enough time to solve such easy tasks, at the same time he doesn't want to anger Sasha, that's why he asked you to help and to find answers for all queries of the 3-rd type.

Input

The first line contains two integers n and mod (1 ≤ n ≤ 10^5, 2 ≤ mod ≤ 10^9 + 9) — the size of the array and the number mod.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the array itself.

The third line contains one integer q(1 ≤ q ≤ 10^5) — the number of queries.

Next q lines satisfy one of the following formats:

  * 1 l r x (1 ≤ l ≤ r ≤ n, 1 ≤ x ≤ 10^5), means that you must multiply each number on the range from l to r by x. 
  * 2 p x (1 ≤ p ≤ n, 1 ≤ x ≤ 10^5), means that you must divide number at the position p by x (divisibility guaranteed). 
  * 3 l r (1 ≤ l ≤ r ≤ n), means that you must find the sum of elements on the range from l to r. 



It is guaranteed that there is at least one query of the 3-rd type.

Output

For each query of the 3-rd type print the answer on a new line modulo mod.

Examples

Input


5 100
4 1 2 3 5
5
3 1 5
1 2 3 6
3 1 2
1 1 5 1
3 2 4


Output


15
10
21


Input


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


Output


1
0
1
0


Input


5 2100
1 2 3 4 5
10
1 1 3 12
1 1 5 10
2 5 50
3 2 4
1 4 4 28
2 4 7
3 1 2
3 3 4
2 3 3
3 1 5


Output


640
360
520
641

Note

The first example:

Inital array is [4, 1, 2, 3, 5] 

  * In the first query, you must calculate the sum of the whole array, it's equal to (4 + 1 + 2 + 3 + 5) mod 100 = 15 mod 100 = 15 
  * In the second query, you must multiply each number on the range from 2 to 3 by 6. The resulting array will be [4, 6, 12, 3, 5] 
  * In the third query, you must calculate the sum on the range from 1 to 2, it's equal to (4 + 6) mod 100 = 10 mod 100 = 10 
  * In the fourth query, you must multiply each number on the range from 1 to 5 by 1. Multiplication by 1 doesn't affect the array. 
  * In the fifth query, you must calculate the sum on the range from 2 to 4, it's equal to (6 + 12 + 3) mod 100 = 21 mod 100 = 21 



The second example:

Inital array is [4, 1, 2, 3, 5] 

  * In the first query, you must calculate the sum of the whole array, it's equal to (4 + 1 + 2 + 3 + 5) mod 2 = 15 mod 2 = 1 
  * In the second query, you must multiply each number on the range from 2 to 3 by 6. The resulting array will be [4, 6, 12, 3, 5] 
  * In the third query, you must calculate the sum on the range from 1 to 2, it's equal to (4 + 6) mod 2 = 10 mod 2 = 0 
  * In the fourth query, you must multiply each number on the range from 1 to 5 by 1. Multiplication by 1 doesn't affect the array. 
  * In the fifth query, you must calculate the sum on the range from 2 to 4, it's equal to (6 + 12 + 3) mod 2 = 21 mod 2 = 1 
  * In the sixth query, you must divide number at the position 3 by 4. 12/4=3, so the array will be [4, 6, 3, 3, 5]. 
  * In the seventh, query you must calculate the sum on the range form 3 to 4, it's equal to (3 + 3) mod 2 = 6 mod 2 = 0 
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 15;
const int LOG = 18;
int n, mod;
vector<int> primeDivisors;
vector<vector<int> > powers;
int fiMOD;
int a[MaxN];
int goodPart[MaxN];
vector<int> f[MaxN];
int phi(int n) {
  int res = n;
  for (int i = 2; i * i <= n; ++i)
    if (n % i == 0) {
      while (n % i == 0) n /= i;
      res -= res / i;
    }
  if (n > 1) res -= res / n;
  return res;
}
int bpow(int a, int b) {
  int res = 1;
  while (b) {
    if (b & 1) res = (long long)res * a % mod;
    b >>= 1;
    a = (long long)a * a % mod;
  }
  return res;
}
struct node {
  vector<int> cnt;
  int sum;
  int mulPrimes;
  bool flag;
} tree[MaxN * 4];
void calcLeafSum(int x) {
  int sum = tree[x].mulPrimes;
  for (int j = 0; j < tree[x].cnt.size(); ++j)
    sum = (long long)sum * powers[j][tree[x].cnt[j]] % mod;
  tree[x].sum = sum;
}
void push(int x) {
  if (!tree[x].flag) return;
  tree[x].flag = false;
  for (int i = 0; i < tree[x].cnt.size(); ++i) {
    tree[x + x].cnt[i] += tree[x].cnt[i];
    tree[x + x + 1].cnt[i] += tree[x].cnt[i];
    tree[x + x].sum =
        (long long)tree[x + x].sum * powers[i][tree[x].cnt[i]] % mod;
    tree[x + x + 1].sum =
        (long long)tree[x + x + 1].sum * powers[i][tree[x].cnt[i]] % mod;
    tree[x].cnt[i] = 0;
  }
  tree[x + x].flag = tree[x + x + 1].flag = true;
  tree[x + x].sum = (long long)tree[x + x].sum * tree[x].mulPrimes % mod;
  tree[x + x + 1].sum =
      (long long)tree[x + x + 1].sum * tree[x].mulPrimes % mod;
  tree[x + x].mulPrimes =
      (long long)tree[x + x].mulPrimes * tree[x].mulPrimes % mod;
  tree[x + x + 1].mulPrimes =
      (long long)tree[x + x + 1].mulPrimes * tree[x].mulPrimes % mod;
  tree[x].mulPrimes = 1;
}
void updateMul(int x, int l, int r, int ll, int rr, int value) {
  if (l > rr || r < ll) return;
  if (l >= ll && r <= rr) {
    for (int i = 0; i < f[value].size(); ++i) tree[x].cnt[i] += f[value][i];
    tree[x].mulPrimes = (long long)tree[x].mulPrimes * goodPart[value] % mod;
    tree[x].sum = (long long)tree[x].sum * value % mod;
    tree[x].flag = true;
    return;
  }
  int mid = (l + r) / 2;
  push(x);
  updateMul(x + x, l, mid, ll, rr, value);
  updateMul(x + x + 1, mid + 1, r, ll, rr, value);
  tree[x].sum = (tree[x + x].sum + tree[x + x + 1].sum) % mod;
}
void updateDiv(int x, int l, int r, int pos, int value) {
  if (l == r) {
    tree[x].mulPrimes =
        (long long)tree[x].mulPrimes * bpow(goodPart[value], fiMOD - 1) % mod;
    for (int i = 0; i < tree[x].cnt.size(); ++i) tree[x].cnt[i] -= f[value][i];
    calcLeafSum(x);
  } else {
    int mid = (l + r) / 2;
    push(x);
    if (pos <= mid)
      updateDiv(x + x, l, mid, pos, value);
    else
      updateDiv(x + x + 1, mid + 1, r, pos, value);
    tree[x].sum = (tree[x + x].sum + tree[x + x + 1].sum) % mod;
  }
}
void build(int x, int l, int r) {
  if (l == r) {
    tree[x].sum = 1;
    tree[x].mulPrimes = 1;
    tree[x].flag = false;
    tree[x].cnt.resize(primeDivisors.size(), 0);
    updateMul(x, l, r, l, r, a[l]);
  } else {
    int mid = (l + r) / 2;
    build(x + x, l, mid);
    build(x + x + 1, mid + 1, r);
    tree[x].sum = (tree[x + x].sum + tree[x + x + 1].sum) % mod;
    tree[x].mulPrimes = 1;
    tree[x].flag = false;
    tree[x].cnt.resize(primeDivisors.size(), 0);
  }
}
int getAns(int x, int l, int r, int ll, int rr) {
  if (l > rr || r < ll) return 0;
  if (l >= ll && r <= rr) return tree[x].sum;
  push(x);
  int mid = (l + r) / 2;
  return (getAns(x + x, l, mid, ll, rr) +
          getAns(x + x + 1, mid + 1, r, ll, rr)) %
         mod;
}
vector<int> factorize(int x) {
  vector<int> res;
  for (int i = 2; i * i <= x; ++i)
    if (x % i == 0) {
      x /= i;
      res.push_back(i);
      while (x % i == 0) x /= i;
    }
  if (x > 1) res.push_back(x);
  return res;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n >> mod;
  fiMOD = phi(mod);
  primeDivisors = factorize(mod);
  powers.resize(primeDivisors.size());
  for (int i = 0; i < powers.size(); ++i) {
    powers[i].resize(MaxN * LOG);
    powers[i][0] = 1;
    for (int j = 1; j < MaxN * LOG; ++j)
      powers[i][j] = (long long)powers[i][j - 1] * primeDivisors[i] % mod;
  }
  for (int i = 1; i < MaxN; ++i) {
    f[i].resize(primeDivisors.size(), 0);
    int x = i;
    for (int j = 0; j < primeDivisors.size(); ++j)
      while (x % primeDivisors[j] == 0) {
        ++f[i][j];
        x /= primeDivisors[j];
      }
    goodPart[i] = x;
  }
  for (int i = 1; i <= n; ++i) cin >> a[i];
  build(1, 1, n);
  int q;
  cin >> q;
  while (q-- > 0) {
    int t;
    cin >> t;
    if (t == 1) {
      int l, r, x;
      cin >> l >> r >> x;
      updateMul(1, 1, n, l, r, x);
    } else if (t == 2) {
      int p, x;
      cin >> p >> x;
      updateDiv(1, 1, n, p, x);
    } else if (t == 3) {
      int l, r;
      cin >> l >> r;
      cout << getAns(1, 1, n, l, r) << '\n';
    }
  }
  return 0;
}
