Problem: There are lots of theories concerning the origin of moon craters. Most scientists stick to the meteorite theory, which says that the craters were formed as a result of celestial bodies colliding with the Moon. The other version is that the craters were parts of volcanoes.

An extraterrestrial intelligence research specialist professor Okulov (the namesake of the Okulov, the author of famous textbooks on programming) put forward an alternate hypothesis. Guess what kind of a hypothesis it was –– sure, the one including extraterrestrial mind involvement. Now the professor is looking for proofs of his hypothesis.

Professor has data from the moon robot that moves linearly in one direction along the Moon surface. The moon craters are circular in form with integer-valued radii. The moon robot records only the craters whose centers lay on his path and sends to the Earth the information on the distance from the centers of the craters to the initial point of its path and on the radii of the craters.

According to the theory of professor Okulov two craters made by an extraterrestrial intelligence for the aims yet unknown either are fully enclosed one in the other or do not intersect at all. Internal or external tangency is acceptable. However the experimental data from the moon robot do not confirm this theory! Nevertheless, professor Okulov is hopeful. He perfectly understands that to create any logical theory one has to ignore some data that are wrong due to faulty measuring (or skillful disguise by the extraterrestrial intelligence that will be sooner or later found by professor Okulov!) That’s why Okulov wants to choose among the available crater descriptions the largest set that would satisfy his theory.

Input

The first line has an integer n (1 ≤ n ≤ 2000) — the number of discovered craters. The next n lines contain crater descriptions in the "ci ri" format, where ci is the coordinate of the center of the crater on the moon robot’s path, ri is the radius of the crater. All the numbers ci and ri are positive integers not exceeding 109. No two craters coincide.

Output

In the first line output the number of craters in the required largest set. In the next line output space-separated numbers of craters that this set consists of. The craters are numbered from 1 to n in the order in which they were given in the input data. The numbers may be output in any order. If the result is not unique, output any.

Examples

Input

4
1 1
2 2
4 1
5 1


Output

3
1 2 4

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
namespace FastIO {
const unsigned BUFFER_SIZE = 1 << 12;
class InputReader {
 protected:
  char buffer[BUFFER_SIZE];
  FILE* file = nullptr;
  size_t ptr = 0;
  size_t len = 0;
  bool isEnd = false;

 public:
  inline bool end() { return isEnd; }
  static inline bool isDigit(char c) { return c >= '0' && c <= '9'; }
  static inline bool isSpace(char c) {
    return (unsigned char)(c - '\t') < 5 || c == ' ';
  }
  static inline bool isNotSpace(char c) { return !isSpace(c); }
  static inline bool isUpper(char c) { return (unsigned char)(c - 'A') < 26; }
  static inline bool isLower(char c) { return (unsigned char)(c - 'a') < 26; }
  static inline bool isAlpha(char c) { return isUpper(c) || isLower(c); }
  static inline bool isNotEndl(char c) { return c != '\n'; }
  InputReader() {}
  InputReader(FILE* _file) : file(_file) {}
  inline bool readChar(char& dest) {
    if (__builtin_expect(ptr == len, false)) {
      len = fread((void*)buffer, 1, BUFFER_SIZE, file);
      ptr = 0;
    }
    if (__builtin_expect(ptr == len, false)) {
      dest = '\0';
      isEnd = true;
      return false;
    }
    dest = buffer[ptr++];
    return true;
  }
  template <class F>
  inline char skipCharacters(F check) {
    char c;
    do {
      if (__builtin_expect(!readChar(c), false)) return '\0';
    } while (!check(c));
    return c;
  }
  template <class T>
  inline int readUInteger(T& dest) {
    T value = 0;
    int length = 0;
    char start = skipCharacters(isDigit);
    if (__builtin_expect(start == '\0', false)) return 0;
    while (isDigit(start)) {
      ++length;
      start -= '0';
      value = value * 10 + start;
      readChar(start);
    }
    ptr--;
    dest = value;
    return length;
  }
  template <class T>
  inline int readInteger(T& dest) {
    char start = skipCharacters([](char c) { return isDigit(c) || c == '-'; });
    if (__builtin_expect(start == '\0', false)) return 0;
    bool neg = start == '-';
    if (neg) readChar(start);
    if (__builtin_expect(start == '\0', false)) return 0;
    ptr--;
    int flag = readUInteger(dest);
    if (neg) dest = -dest;
    return flag;
  }
  template <class T>
  inline bool readFloat(T& dest) {
    char start = skipCharacters([](char c) { return isDigit(c) || c == '-'; });
    if (__builtin_expect(start == '\0', false)) return 0;
    bool neg = start == '-';
    if (neg) readChar(start);
    if (__builtin_expect(start == '\0', false)) return 0;
    ptr--;
    unsigned long long p;
    if (!readUInteger(p)) return false;
    dest = static_cast<T>(p);
    char c;
    readChar(c);
    if (c == '.') {
      unsigned long long q;
      int l;
      l = readUInteger(q);
      if (l > 0) {
        unsigned long long pw = 1;
        while (l) {
          pw *= 10;
          --l;
        }
        dest += static_cast<T>(q) / pw;
      }
    } else
      --ptr;
    if (neg) dest = -dest;
    return true;
  }
  template <class F>
  inline int readString(string& dest, F check) {
    dest.clear();
    char c = skipCharacters(check);
    if (__builtin_expect(c == '\0', false)) {
      dest = "";
      return 0;
    }
    int l = 0;
    while (check(c)) {
      dest += c;
      ++l;
      if (__builtin_expect(!readChar(c), false)) break;
    }
    --ptr;
    return l;
  }
  inline int readString(string& dest) { return readString(dest, isNotSpace); }
  template <class F>
  inline int readCString(char* dest, F check) {
    char c = skipCharacters(check);
    if (__builtin_expect(c == '\0', false)) {
      *dest = '\0';
      return 0;
    }
    int l = 0;
    while (check(c)) {
      *dest = c;
      ++dest;
      ++l;
      if (__builtin_expect(!readChar(c), false)) break;
    }
    --ptr;
    *dest = '\0';
    return l;
  }
  inline int readCString(char* dest) { return readCString(dest, isNotSpace); }
};
class OutputWriter {
 protected:
  char buffer[BUFFER_SIZE];
  char tmp[BUFFER_SIZE];
  FILE* file;
  size_t len = 0;
  int tptr = 0;
  unsigned long long basePw = 1;
  int prec = 0;
  template <class T>
  inline void processUInteger(T what) {
    tptr = 0;
    while (what > 0) {
      tmp[tptr++] = what % 10;
      what /= 10;
    }
  }

 public:
  OutputWriter() : file(nullptr) {}
  OutputWriter(FILE* _file) : file(_file) {}
  inline void flush() {
    fwrite((void*)buffer, 1, len, file);
    len = 0;
  }
  ~OutputWriter() { flush(); }
  inline void checkFlush(size_t space = 0) {
    if (__builtin_expect(len + space >= BUFFER_SIZE, false)) flush();
  }
  inline void precision(int val) {
    basePw = 1;
    prec = 0;
    while (val > 0) {
      basePw *= 10;
      --val;
      ++prec;
    }
  }
  inline void writeChar(char c) {
    checkFlush(1);
    buffer[len++] = c;
  }
  template <class T>
  inline void writeUInteger(T what) {
    if (what == 0) {
      writeChar('0');
      return;
    }
    processUInteger(what);
    checkFlush(tptr);
    for (int i = tptr - 1; i >= 0; i--) buffer[len++] = tmp[i] + '0';
  }
  template <class T>
  inline void writeUInteger(T what, char delim) {
    writeUInteger(what);
    writeChar(delim);
  }
  template <class T>
  inline void writeInteger(T what) {
    if (what < 0) {
      writeChar('-');
      what = -what;
    }
    writeUInteger(what);
  }
  template <class T>
  inline void writeInteger(T what, char delim) {
    writeInteger(what);
    writeChar(delim);
  }
  inline void writeString(const string& s) {
    for (char c : s) writeChar(c);
  }
  inline void writeString(const string& s, char delim) {
    writeString(s);
    writeChar(delim);
  }
  inline void writeCString(const char* s) {
    while (*s != '\0') writeChar(*(s++));
  }
  inline void writeCString(const char* s, char delim) {
    writeCString(s);
    writeChar(delim);
  }
  template <class T>
  inline void writeFloat(T what) {
    bool neg = signbit(what);
    if (neg) {
      what = -what;
      writeChar('-');
    }
    if (isnan(what)) {
      writeChar('N');
      writeChar('a');
      writeChar('N');
      return;
    }
    if (isinf(what)) {
      writeChar('I');
      writeChar('n');
      writeChar('f');
      return;
    }
    auto p = static_cast<unsigned long long>(what);
    auto q = static_cast<unsigned long long>((what - p) * basePw + T(0.5));
    if (q >= basePw) {
      ++p;
      q = 0;
    }
    writeUInteger(p);
    if (prec == 0) return;
    writeChar('.');
    processUInteger(q);
    for (int i = tptr; i < prec; i++) writeChar('0');
    checkFlush(tptr);
    for (int i = tptr - 1; i >= 0; i--) buffer[len++] = tmp[i] + '0';
  }
  template <class T>
  inline void writeFloat(T what, char delim) {
    writeFloat(what);
    writeChar(delim);
  }
};
}  // namespace FastIO
struct segment {
  long long first, second, id;
};
const int N = (int)2e3 + 3;
int n;
segment seg[N];
int dcp[N], dp[2 * N];
int pos[N];
vector<int> from[N];
int fjgjgjgjghd[2 * N];
int idx[2 * N];
int L[N], R[N];
vector<int> ri[2 * N];
int in[N];
int sz = 0;
vector<int> ans;
void restore(int i) {
  ans.push_back(i);
  for (auto x : (from[i])) restore(x);
}
bool inside(segment a, segment b) {
  return b.first <= a.first && a.second <= b.second;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cin >> n;
  for (auto i = (0); i < (n); i++) {
    int c, r;
    cin >> c >> r;
    int l = c - r;
    r += c;
    seg[i] = {l, r, i};
  }
  seg[n] = {-(int)2e9, (int)2e9, n};
  ++n;
  sort(seg, seg + n, [](const segment& a, const segment& b) {
    return a.second - a.first < b.second - b.first;
  });
  for (auto i = (0); i < (n); i++) {
    sz = 0;
    for (auto j = (0); j < (i); j++) {
      if (inside(seg[j], seg[i])) in[sz++] = j;
    }
    int is = 0;
    for (auto j = (0); j < (sz); j++) {
      idx[is++] = seg[in[j]].first;
      idx[is++] = seg[in[j]].second;
    }
    sort(idx, idx + is);
    is = unique(idx, idx + is) - idx;
    for (auto j = (0); j < (is); j++) ri[j].clear();
    for (auto j = (0); j < (sz); j++) {
      L[j] = lower_bound(idx, idx + is, seg[in[j]].first) - idx;
      R[j] = lower_bound(idx, idx + is, seg[in[j]].second) - idx;
      ri[R[j]].push_back(j);
    }
    dcp[i] = 1;
    fjgjgjgjghd[0] = -1;
    for (auto j = (0); j < (is); j++) {
      dp[j] = 0;
      fjgjgjgjghd[j] = -1;
      if (j) dp[j] = dp[j - 1];
      for (auto k : (ri[j])) {
        dp[j] = max(dp[j], dcp[in[k]] + dp[L[k]]);
        if (dp[j] == dcp[in[k]] + dp[L[k]]) fjgjgjgjghd[j] = k;
      }
      dcp[i] = max(dcp[i], 1 + dp[j]);
      if (dcp[i] == 1 + dp[j]) {
        pos[i] = j;
      }
    }
    int x = pos[i];
    while (x >= 0) {
      if (fjgjgjgjghd[x] == -1) {
        --x;
        continue;
      }
      from[i].push_back(in[fjgjgjgjghd[x]]);
      x = L[fjgjgjgjghd[x]];
    }
  }
  cout << dcp[n - 1] - 1 << endl;
  restore(n - 1);
  for (auto x : (ans)) {
    if (x != n - 1) cout << seg[x].id + 1 << ' ';
  }
  return 0;
}