#include <bits/stdc++.h>
#pragma GCC optimize(2)
namespace OI {
template <class T>
T gcd(T x, T y) {
  return !y ? x : gcd(y, x % y);
}
template <class T>
T Fabs(T x) {
  return x < 0 ? -x : x;
}
template <class T>
void rd(T &x) {
  x = 0;
  int pre = 1;
  char c;
  while (!isdigit(c = getchar()))
    if (c == '-') pre = -1;
  do {
    x = (x << 3) + (x << 1) + (c ^ 48);
  } while (isdigit(c = getchar()));
  x *= pre;
}
template <class T>
void pt(T x) {
  if (x < 0) putchar('-'), x = -x;
  if (x > 9) pt(x / 10);
  putchar(x % 10 ^ 48);
}
}  // namespace OI
using namespace OI;
using namespace std;
const int N = 4005;
int n, m, x[N], y[N], d[N], dp[N][N], g[N][N], pre[N][N];
vector<int> G[N];
void print(int l, int r) {
  if (!dp[l][r] || l > r) return;
  if (pre[l][r])
    print(l, pre[l][r]), print(pre[l][r], r);
  else
    print(l + 1, r);
  if (g[l][r]) pt(g[l][r]), putchar(' ');
}
int main() {
  rd(n);
  for (int i = 1, c, r; i <= n; i++) {
    rd(c), rd(r);
    x[i] = d[++m] = c - r;
    y[i] = d[++m] = c + r;
  }
  sort(d + 1, d + m + 1);
  m = unique(d + 1, d + m + 1) - d - 1;
  for (int i = 1; i <= n; i++) {
    x[i] = lower_bound(d + 1, d + m + 1, x[i]) - d;
    y[i] = lower_bound(d + 1, d + m + 1, y[i]) - d;
    G[x[i]].push_back(y[i]);
    g[x[i]][y[i]] = i;
  }
  for (int i = m; i > 0; i--)
    for (int j = i; j <= m; j++) {
      dp[i][j] = dp[i + 1][j];
      for (auto it : G[i])
        if (it < j && dp[i][it] + dp[it][j] > dp[i][j])
          dp[i][j] = dp[i][it] + dp[it][j], pre[i][j] = it;
      dp[i][j] += g[i][j] > 0;
    }
  pt(dp[1][m]), puts("");
  print(1, m);
  return 0;
}
