#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct node {
  long long cnt;
  vector<pair<int, int>> st, ed;
} t[N << 1];
int n, m, x;
int a[N];
node merge(node a, node b) {
  if (!a.ed.size()) return b;
  if (!b.ed.size()) return a;
  node ret;
  ret.cnt = a.cnt + b.cnt;
  long long tot = 0;
  for (auto &i : a.ed) {
    for (auto &j : b.st) {
      if (((i.first | j.first) >= x)) {
        tot += (1ll * i.second * j.second);
      }
    }
  }
  ret.cnt += tot;
  ret.st = a.st;
  int tmp;
  tmp = ret.st.back().first;
  for (auto &i : b.st) {
    if (((i.first | tmp) == tmp)) {
      ret.st.back().second += i.second;
    } else {
      ret.st.push_back({i.first | tmp, i.second});
      tmp |= i.first;
    }
  }
  ret.ed = b.ed;
  tmp = ret.ed.back().first;
  for (auto &i : a.ed) {
    if ((i.first | tmp) == tmp) {
      ret.ed.back().second += i.second;
    } else {
      ret.ed.push_back({i.first | tmp, i.second});
      tmp |= i.first;
    }
  }
  return ret;
}
void pushup(int x) { t[x] = merge(t[x << 1], t[x << 1 | 1]); }
void build(int now, int l, int r) {
  if (l == r) {
    t[now].ed.push_back({a[l], 1});
    t[now].st.push_back({a[l], 1});
    if (a[l] >= x) {
      t[now].cnt = 1;
    } else
      t[now].cnt = 0;
    return;
  }
  int mid = (l + r) >> 1;
  build(now << 1, l, mid);
  build(now << 1 | 1, mid + 1, r);
  pushup(now);
}
void modify(int now, int l, int r, int y, int z) {
  if (l == r) {
    a[y] = z;
    t[now].st.clear();
    t[now].ed.clear();
    t[now].st.push_back({z, 1});
    t[now].ed.push_back({z, 1});
    if (a[l] >= x) {
      t[now].cnt = 1;
    } else
      t[now].cnt = 0;
    return;
  }
  int mid = (l + r) >> 1;
  if (y <= mid) {
    modify(now << 1, l, mid, y, z);
  } else
    modify(now << 1 | 1, mid + 1, r, y, z);
  pushup(now);
}
node query(int now, int l, int r, int L, int R) {
  if (L <= l && r <= R) {
    return t[now];
  }
  node ret;
  int mid = (l + r) >> 1;
  if (L <= mid) ret = merge(ret, query(now << 1, l, mid, L, R));
  if (R > mid) ret = merge(ret, query(now << 1 | 1, mid + 1, r, L, R));
  return ret;
}
int main() {
  scanf("%d%d%d", &n, &m, &x);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &a[i]);
  }
  build(1, 1, n);
  for (int i = 1; i <= m; ++i) {
    int opt;
    scanf("%d", &opt);
    if (opt == 1) {
      int x, y;
      scanf("%d%d", &x, &y);
      a[x] = y;
      modify(1, 1, n, x, y);
    } else {
      int l, r;
      scanf("%d%d", &l, &r);
      printf("%lld\n", query(1, 1, n, l, r).cnt);
    }
  }
  return 0;
}

### Prompt

Develop a solution in Cpp to the problem described below:

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). 

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct node {
  long long cnt;
  vector<pair<int, int>> st, ed;
} t[N << 1];
int n, m, x;
int a[N];
node merge(node a, node b) {
  if (!a.ed.size()) return b;
  if (!b.ed.size()) return a;
  node ret;
  ret.cnt = a.cnt + b.cnt;
  long long tot = 0;
  for (auto &i : a.ed) {
    for (auto &j : b.st) {
      if (((i.first | j.first) >= x)) {
        tot += (1ll * i.second * j.second);
      }
    }
  }
  ret.cnt += tot;
  ret.st = a.st;
  int tmp;
  tmp = ret.st.back().first;
  for (auto &i : b.st) {
    if (((i.first | tmp) == tmp)) {
      ret.st.back().second += i.second;
    } else {
      ret.st.push_back({i.first | tmp, i.second});
      tmp |= i.first;
    }
  }
  ret.ed = b.ed;
  tmp = ret.ed.back().first;
  for (auto &i : a.ed) {
    if ((i.first | tmp) == tmp) {
      ret.ed.back().second += i.second;
    } else {
      ret.ed.push_back({i.first | tmp, i.second});
      tmp |= i.first;
    }
  }
  return ret;
}
void pushup(int x) { t[x] = merge(t[x << 1], t[x << 1 | 1]); }
void build(int now, int l, int r) {
  if (l == r) {
    t[now].ed.push_back({a[l], 1});
    t[now].st.push_back({a[l], 1});
    if (a[l] >= x) {
      t[now].cnt = 1;
    } else
      t[now].cnt = 0;
    return;
  }
  int mid = (l + r) >> 1;
  build(now << 1, l, mid);
  build(now << 1 | 1, mid + 1, r);
  pushup(now);
}
void modify(int now, int l, int r, int y, int z) {
  if (l == r) {
    a[y] = z;
    t[now].st.clear();
    t[now].ed.clear();
    t[now].st.push_back({z, 1});
    t[now].ed.push_back({z, 1});
    if (a[l] >= x) {
      t[now].cnt = 1;
    } else
      t[now].cnt = 0;
    return;
  }
  int mid = (l + r) >> 1;
  if (y <= mid) {
    modify(now << 1, l, mid, y, z);
  } else
    modify(now << 1 | 1, mid + 1, r, y, z);
  pushup(now);
}
node query(int now, int l, int r, int L, int R) {
  if (L <= l && r <= R) {
    return t[now];
  }
  node ret;
  int mid = (l + r) >> 1;
  if (L <= mid) ret = merge(ret, query(now << 1, l, mid, L, R));
  if (R > mid) ret = merge(ret, query(now << 1 | 1, mid + 1, r, L, R));
  return ret;
}
int main() {
  scanf("%d%d%d", &n, &m, &x);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &a[i]);
  }
  build(1, 1, n);
  for (int i = 1; i <= m; ++i) {
    int opt;
    scanf("%d", &opt);
    if (opt == 1) {
      int x, y;
      scanf("%d%d", &x, &y);
      a[x] = y;
      modify(1, 1, n, x, y);
    } else {
      int l, r;
      scanf("%d%d", &l, &r);
      printf("%lld\n", query(1, 1, n, l, r).cnt);
    }
  }
  return 0;
}

```