Sonya has an array a_1, a_2, …, a_n consisting of n integers and also one non-negative integer x. She has to perform m queries of two types:

  * 1 i y: replace i-th element by value y, i.e. to perform an operation a_{i} := y; 
  * 2 l r: find the number of pairs (L, R) that l≤ L≤ R≤ r and bitwise OR of all integers in the range [L, R] is at least x (note that x is a constant for all queries). 



Can you help Sonya perform all her queries?

Bitwise OR is a binary operation on a pair of non-negative integers. To calculate the bitwise OR of two numbers, you need to write both numbers in binary notation. The result is a number, in binary, which contains a one in each digit if there is a one in the binary notation of at least one of the two numbers. For example, 10 OR 19 = 1010_2 OR 10011_2 = 11011_2 = 27.

Input

The first line contains three integers n, m, and x (1≤ n, m≤ 10^5, 0≤ x<2^{20}) — the number of numbers, the number of queries, and the constant for all queries.

The second line contains n integers a_1, a_2, …, a_n (0≤ a_i<2^{20}) — numbers of the array.

The following m lines each describe an query. A line has one of the following formats:

  * 1 i y (1≤ i≤ n, 0≤ y<2^{20}), meaning that you have to replace a_{i} by y; 
  * 2 l r (1≤ l≤ r≤ n), meaning that you have to find the number of subarrays on the segment from l to r that the bitwise OR of all numbers there is at least x. 

Output

For each query of type 2, print the number of subarrays such that the bitwise OR of all the numbers in the range is at least x.

Examples

Input

4 8 7
0 3 6 1
2 1 4
2 3 4
1 1 7
2 1 4
2 1 3
2 1 1
1 3 0
2 1 4


Output

5
1
7
4
1
4


Input

5 5 7
6 0 3 15 2
2 1 5
1 4 4
2 1 5
2 3 5
2 1 4


Output

9
7
2
4

Note

In the first example, there are an array [0, 3, 6, 1] and queries: 

  1. on the segment [1…4], you can choose pairs (1, 3), (1, 4), (2, 3), (2, 4), and (3, 4); 
  2. on the segment [3…4], you can choose pair (3, 4); 
  3. the first number is being replacing by 7, after this operation, the array will consist of [7, 3, 6, 1]; 
  4. on the segment [1…4], you can choose pairs (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), and (3, 4); 
  5. on the segment [1…3], you can choose pairs (1, 1), (1, 2), (1, 3), and (2, 3); 
  6. on the segment [1…1], you can choose pair (1, 1); 
  7. the third number is being replacing by 0, after this operation, the array will consist of [7, 3, 0, 1]; 
  8. on the segment [1…4], you can choose pairs (1, 1), (1, 2), (1, 3), and (1, 4). 



In the second example, there are an array [6, 0, 3, 15, 2] are queries: 

  1. on the segment [1…5], you can choose pairs (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5), (4, 4), and (4, 5); 
  2. the fourth number is being replacing by 4, after this operation, the array will consist of [6, 0, 3, 4, 2]; 
  3. on the segment [1…5], you can choose pairs (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 4), and (3, 5); 
  4. on the segment [3…5], you can choose pairs (3, 4) and (3, 5); 
  5. on the segment [1…4], you can choose pairs (1, 3), (1, 4), (2, 4), and (3, 4). 
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, N = 1e5 + 7;
int n, m, x;
struct T {
  long long ans;
  vector<pair<int, int> > l, r;
  T() {}
  T(int val) {
    l = r = {{val, 1}};
    ans = val >= x;
  }
};
vector<pair<int, int> > cmb(vector<pair<int, int> > a,
                            vector<pair<int, int> > b) {
  assert(a.size());
  for (pair<int, int> p : b) {
    if ((p.first | a.back().first) == a.back().first)
      a.back().second += p.second;
    else
      a.emplace_back(p.first | a.back().first, p.second);
  }
  return a;
}
T operator+(const T a, const T b) {
  T c;
  c.ans = a.ans + b.ans;
  c.l = cmb(a.l, b.l);
  c.r = cmb(b.r, a.r);
  long long sum = 0;
  for (int i = 0, j = (int)b.l.size() - 1; i < a.r.size(); i++) {
    while (j >= 0 && (b.l[j].first | a.r[i].first) >= x)
      sum += b.l[j].second, j--;
    c.ans += sum * a.r[i].second;
  }
  return c;
}
T t[N * 4];
int a[N];
void build(int v = 1, int tl = 0, int tr = n) {
  if (tr - tl == 1) {
    t[v] = T(a[tl]);
    return;
  }
  int tm = (tl + tr) / 2;
  build(v * 2, tl, tm);
  build(v * 2 + 1, tm, tr);
  t[v] = t[v * 2] + t[v * 2 + 1];
}
void upd(int pos, int val, int v = 1, int tl = 0, int tr = n) {
  if (tr - tl == 1) {
    t[v] = T(val);
    return;
  }
  int tm = (tl + tr) / 2;
  if (pos < tm)
    upd(pos, val, v * 2, tl, tm);
  else
    upd(pos, val, v * 2 + 1, tm, tr);
  t[v] = t[v * 2] + t[v * 2 + 1];
}
T qry(int l, int r, int v = 1, int tl = 0, int tr = n) {
  if (l <= tl && tr <= r) return t[v];
  int tm = (tl + tr) / 2;
  if (r <= tm)
    return qry(l, r, v * 2, tl, tm);
  else if (l >= tm)
    return qry(l, r, v * 2 + 1, tm, tr);
  else
    return qry(l, r, v * 2, tl, tm) + qry(l, r, v * 2 + 1, tm, tr);
}
signed main() {
  std::ios::sync_with_stdio(0);
  std::cin.tie(0);
  ;
  cin >> n >> m >> x;
  for (int i = 0; i < n; i++) cin >> a[i];
  build();
  while (m--) {
    int op;
    cin >> op;
    if (op == 1) {
      int i, y;
      cin >> i >> y;
      upd(i - 1, y);
    } else {
      int l, r;
      cin >> l >> r;
      cout << qry(l - 1, r).ans << endl;
    }
  }
}
