#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int inf = 1e9 + 7;
int n, m;
int p[maxn], a[maxn];
int nxt[maxn], pre[maxn];
set<pair<int, int> > S;
pair<int, int> c[maxn];
int time(int x, int y) {
  if (x == y) return inf;
  long long p1 = p[x], p2 = p[y];
  if (x > y) p2 = (p2 + a[y]) % m;
  if (p2 < p1) p2 += m;
  if (p2 - p1 <= a[x]) return 1;
  if (a[y] >= a[x]) return inf;
  int l = 1, r = inf, ans = inf;
  while (l <= r) {
    int mid = (l + r) / 2;
    if (p1 + 1ll * a[x] * mid >= p2 + 1ll * a[y] * (mid - 1))
      ans = mid, r = mid - 1;
    else
      l = mid + 1;
  }
  return ans;
}
int main() {
  int cc;
  scanf("%d%d", &n, &m);
  for (int i = 0; i < n; i++) {
    scanf("%d%d", &p[i], &a[i]);
    p[i]--;
    c[i].first = p[i];
    c[i].second = i;
  }
  sort(c, c + n);
  for (int i = 0; i < n; i++) {
    nxt[c[i].second] = c[(i + 1) % n].second;
    pre[c[i].second] = c[(i - 1 + n) % n].second;
  }
  for (int i = 0; i < n; i++) {
  }
  for (int i = 0; i < n; i++) S.insert(make_pair(time(i, nxt[i]), i));
  while (!S.empty()) {
    pair<int, int> now = *S.begin();
    if (now.first == inf) break;
    S.erase(now);
    int x = now.second;
    S.erase(make_pair(time(nxt[x], nxt[nxt[x]]), nxt[x]));
    S.erase(make_pair(time(pre[x], x), pre[x]));
    p[x] += now.first, a[x]--;
    nxt[x] = nxt[nxt[x]];
    pre[nxt[x]] = x;
    S.insert(make_pair(time(pre[x], x), pre[x]));
    S.insert(make_pair(time(x, nxt[x]), x));
  }
  printf("%d\n", S.size());
  for (auto s : S) printf("%d ", s.second + 1);
  printf("\n");
}

### Prompt

In Cpp, your task is to solve the following problem:

Ostap Bender recently visited frog farm and was inspired to create his own frog game.

Number of frogs are places on a cyclic gameboard, divided into m cells. Cells are numbered from 1 to m, but the board is cyclic, so cell number 1 goes right after the cell number m in the direction of movement. i-th frog during its turn can jump for ai cells.

Frogs move in turns, game starts with a move by frog 1. On its turn i-th frog moves ai cells forward, knocking out all the frogs on its way. If there is a frog in the last cell of the path of the i-th frog, that frog is also knocked out. After this the value ai is decreased by the number of frogs that were knocked out during this turn. If ai is zero or goes negative, then i-th frog doesn't make moves anymore.

After frog number 1 finishes its turn, frog number 2 starts to move, then frog number 3 and so on. After the frog number n makes its move, frog 1 starts to move again, then frog 2 and so on this process goes forever. If some frog was already knocked out from the board, we consider that it skips all its moves.

Help Ostap to identify, what frogs will stay on the board at the end of a game?

Input

First line of the input contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 109, n ≤ m) — number of frogs and gameboard size, respectively.

Following n lines contains frogs descriptions — two integers pi and ai (1 ≤ pi, ai ≤ m) — the number of cell occupied by i-th frog initially and initial jump length. All pi are guaranteed to be distinct.

Output

In the first line output number of frogs on the final gameboard. In the second line output their numbers in any order.

Examples

Input

3 5
2 1
5 3
4 3


Output

1
3 

Input

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


Output

2
1 4 

Note

In the first sample first frog jumps 1 cell and finishes in cell number 3. Second frog jumps for 3 cells and finishes on cell number 3, knocking out frog number 1. Current jump length for frog number 2 is now 2. Third frog jumps to cell 2, then second frog jumps to cell 5. Third frog in turn finishes in cell 5 and removes frog 2 from the gameboard. Now, it's the only remaining frog in the game.

In the second sample first frog jumps 2 cells and knocks out frogs in cells 2 and 3. Its value ai is now 0. Then fourth frog jumps and knocks out fifth frog and its ai is now 0 too. These two frogs will remains on the gameboard forever.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int inf = 1e9 + 7;
int n, m;
int p[maxn], a[maxn];
int nxt[maxn], pre[maxn];
set<pair<int, int> > S;
pair<int, int> c[maxn];
int time(int x, int y) {
  if (x == y) return inf;
  long long p1 = p[x], p2 = p[y];
  if (x > y) p2 = (p2 + a[y]) % m;
  if (p2 < p1) p2 += m;
  if (p2 - p1 <= a[x]) return 1;
  if (a[y] >= a[x]) return inf;
  int l = 1, r = inf, ans = inf;
  while (l <= r) {
    int mid = (l + r) / 2;
    if (p1 + 1ll * a[x] * mid >= p2 + 1ll * a[y] * (mid - 1))
      ans = mid, r = mid - 1;
    else
      l = mid + 1;
  }
  return ans;
}
int main() {
  int cc;
  scanf("%d%d", &n, &m);
  for (int i = 0; i < n; i++) {
    scanf("%d%d", &p[i], &a[i]);
    p[i]--;
    c[i].first = p[i];
    c[i].second = i;
  }
  sort(c, c + n);
  for (int i = 0; i < n; i++) {
    nxt[c[i].second] = c[(i + 1) % n].second;
    pre[c[i].second] = c[(i - 1 + n) % n].second;
  }
  for (int i = 0; i < n; i++) {
  }
  for (int i = 0; i < n; i++) S.insert(make_pair(time(i, nxt[i]), i));
  while (!S.empty()) {
    pair<int, int> now = *S.begin();
    if (now.first == inf) break;
    S.erase(now);
    int x = now.second;
    S.erase(make_pair(time(nxt[x], nxt[nxt[x]]), nxt[x]));
    S.erase(make_pair(time(pre[x], x), pre[x]));
    p[x] += now.first, a[x]--;
    nxt[x] = nxt[nxt[x]];
    pre[nxt[x]] = x;
    S.insert(make_pair(time(pre[x], x), pre[x]));
    S.insert(make_pair(time(x, nxt[x]), x));
  }
  printf("%d\n", S.size());
  for (auto s : S) printf("%d ", s.second + 1);
  printf("\n");
}

```