Problem: You are given a set of n≥ 2 pairwise different points with integer coordinates. Your task is to partition these points into two nonempty groups A and B, such that the following condition holds:

For every two points P and Q, write the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between them on the blackboard: if they belong to the same group — with a yellow pen, and if they belong to different groups — with a blue pen. Then no yellow number is equal to any blue number.

It is guaranteed that such a partition exists for any possible input. If there exist multiple partitions, you are allowed to output any of them.

Input

The first line contains one integer n (2 ≤ n ≤ 10^3) — the number of points.

The i-th of the next n lines contains two integers x_i and y_i (-10^6 ≤ x_i, y_i ≤ 10^6) — the coordinates of the i-th point. 

It is guaranteed that all n points are pairwise different.

Output

In the first line, output a (1 ≤ a ≤ n-1) — the number of points in a group A.

In the second line, output a integers — the indexes of points that you include into group A.

If there are multiple answers, print any.

Examples

Input


3
0 0
0 1
1 0


Output


1
1 

Input


4
0 1
0 -1
1 0
-1 0


Output


2
1 2 

Input


3
-2 1
1 1
-1 0


Output


1
2 

Input


6
2 5
0 3
-4 -1
-5 -4
1 0
3 -1


Output


1
6 

Input


2
-1000000 -1000000
1000000 1000000


Output


1
1 

Note

In the first example, we set point (0, 0) to group A and points (0, 1) and (1, 0) to group B. In this way, we will have 1 yellow number √{2} and 2 blue numbers 1 on the blackboard.

In the second example, we set points (0, 1) and (0, -1) to group A and points (-1, 0) and (1, 0) to group B. In this way, we will have 2 yellow numbers 2, 4 blue numbers √{2} on the blackboard.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
struct BigNum {
  vector<long long> value;
  void set(long long x) {
    value = *(new vector<long long>);
    value.push_back(x);
  }
  void duplicate(BigNum other) { value = other.value; }
  void add(BigNum other) {
    vector<long long> o = other.value;
    if (o.size() > value.size()) {
      vector<long long> t = value;
      value = o;
      o = t;
    }
    for (int i = 0; i < o.size(); i += 1) {
      value[i] += o[i];
      if (i < value.size() - 1 && value[i] >= (long long)1e9) {
        value[i + 1] += value[i] / (long long)1e9;
        value[i] = value[i] % (long long)1e9;
      }
    }
    if (value.back() >= (long long)1e9) {
      value.push_back(value.back() / (long long)1e9);
      value[value.size() - 2] = value[value.size() - 2] % (long long)1e9;
    }
  }
  void mul(long long mul) {
    for (int i = 0; i < value.size(); i += 1) {
      value[i] *= mul;
    }
    for (int i = 0; i < value.size() - 1; i += 1) {
      if (value[i] >= (long long)1e9) {
        value[i + 1] += value[i] / (long long)1e9;
        value[i] = value[i] % (long long)1e9;
      }
    }
    if (value.back() >= (long long)1e9) {
      value.push_back(value.back() / (long long)1e9);
      value[value.size() - 2] = value[value.size() - 2] % (long long)1e9;
    }
  }
  long double div(BigNum other1, BigNum other2) {
    int s = value.size();
    long double current = value.back();
    if (s >= 2) {
      current += ((long double)value[s - 2]) / (long long)1e9;
    }
    if (s >= 3) {
      current +=
          ((long double)value[s - 3]) / ((long long)1e9 * (long long)1e9);
    }
    int s1 = other1.value.size();
    int s2 = other2.value.size();
    long double other = 0;
    if (s1 + s2 - 1 == s) {
      other += other1.value.back() * other2.value.back();
      if (s1 >= 2) {
        other += ((long double)other1.value[s1 - 2] * other2.value.back()) /
                 (long long)1e9;
      }
      if (s2 >= 2) {
        other += ((long double)other2.value[s2 - 2] * other1.value.back()) /
                 (long long)1e9;
      }
      if (s1 >= 3) {
        other += ((long double)other1.value[s1 - 3] * other2.value.back()) /
                 ((long long)1e9 * (long long)1e9);
      }
      if (s2 >= 3) {
        other += ((long double)other2.value[s2 - 3] * other1.value.back()) /
                 ((long long)1e9 * (long long)1e9);
      }
    }
    if (s1 + s2 - 1 == s - 1) {
      other += other1.value.back() * other2.value.back();
      if (s1 >= 2) {
        other += ((long double)other1.value[s1 - 2] * other2.value.back()) /
                 (long long)1e9;
      }
      if (s2 >= 2) {
        other += ((long double)other2.value[s2 - 2] * other1.value.back()) /
                 (long long)1e9;
      }
      other /= (long long)1e9;
    }
    if (s1 + s2 - 1 == s - 2) {
      other += other1.value.back() * other2.value.back();
      other /= (long long)1e9 * (long long)1e9;
    }
    return other / current;
  }
  string stringify() {
    string out = to_string(value.back());
    for (int i = value.size() - 1 - 1; i > -1; i -= 1) {
      string cur = to_string(value[i] + (long long)1e9);
      out += cur.substr(1);
    }
    return out;
  }
};
long long gcd(long long a, long long b) {
  if (b == 0) {
    return a;
  }
  return gcd(b, a % b);
}
long long triangle(long long x) { return (((long long)(x + 1)) * (x)) / 2; }
long long modInverse(long long a) {
  long long m = 1000000007;
  long long y = 0, x = 1;
  while (a > 1) {
    long long q = a / m;
    long long t = m;
    m = a % m, a = t;
    t = y;
    y = x - q * y;
    x = t;
  }
  if (x < 0) {
    x += 1000000007;
  }
  return x;
}
long long modInverse(long long a, long long b) {
  long long m = b;
  long long y = 0, x = 1;
  while (a > 1) {
    long long q = a / m;
    long long t = m;
    m = a % m, a = t;
    t = y;
    y = x - q * y;
    x = t;
  }
  if (x < 0) {
    x += b;
  }
  return x;
}
long long pow(long long a, long long b) {
  if (a <= 1) {
    return a;
  }
  if (b == 0) {
    return 1;
  }
  if (b % 2 == 0) {
    return pow((a * a) % 1000000007, b / 2) % 1000000007;
  }
  return (a * pow((a * a) % 1000000007, b / 2)) % 1000000007;
}
vector<long long> dev(vector<pair<long long, long long> > divisors) {
  if (divisors.size() == 0) {
    vector<long long> cur;
    cur.push_back(1);
    return cur;
  }
  long long x = divisors.back().first;
  long long n = divisors.back().second;
  divisors.pop_back();
  vector<long long> ans = dev(divisors);
  vector<long long> cur;
  long long xi = 1;
  for (int i = 0; i < n + 1; i += 1) {
    for (int j = 0; j < ans.size(); j += 1) {
      cur.push_back(ans[j] * xi);
    }
    xi *= x;
  }
  return cur;
}
void add(vector<int>& x, vector<int>& y) {
  for (int i = 0; i < x.size(); i += 1) {
    x[i] += y[i];
  }
}
struct pt {
  long long x, y;
  long long d() const { return x * x + y * y; }
};
inline pt operator-(const pt& a) { return {-a.x, -a.y}; }
inline pt operator+(const pt& a, const pt& b) { return {a.x + b.x, a.y + b.y}; }
inline pt operator-(const pt& a, const pt& b) { return {a.x - b.x, a.y - b.y}; }
inline long long operator*(const pt& a, const pt& b) {
  return a.x * b.y - a.y * b.x;
}
inline bool operator<(const pt& a, const pt& b) { return a * b < 0; }
bool llll(const pt& a, const pt& b) { return a * b > 0; }
inline bool operator<=(const pt& a, const pt& b) { return a * b <= 0; }
inline long long operator/(const pt& a, const pt& b) {
  return a.x * b.x + a.y * b.y;
}
inline bool operator==(const pt& a, const pt& b) {
  return a.x == b.x && a.y == b.y;
}
inline bool operator!=(const pt& a, const pt& b) {
  return a.x != b.x || a.y != b.y;
}
pt o = {0, 0};
bool comp(pt a, pt b) { return (a - o) * (b - o) < 0; }
bool isprime(long long a) {
  if (a == 1) {
    return false;
  }
  for (int i = 2; i * i <= a; i++) {
    if (a % i == 0) {
      return false;
    }
  }
  return true;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  long long n;
  cin >> n;
  vector<pt> x(n);
  for (int i = 0; i < n; i += 1) {
    cin >> x[i].x;
    cin >> x[i].y;
  }
  while (true) {
    int black = 0;
    int white = 0;
    for (int i = 0; i < n; i += 1) {
      if (abs(x[i].x + x[i].y) % 2) {
        black++;
      } else {
        white++;
      }
    }
    if (black == 0) {
      for (int i = 0; i < n; i += 1) {
        pt xx;
        xx.x = (x[i].x + x[i].y) / 2;
        xx.y = (x[i].x - x[i].y) / 2;
        x[i] = xx;
      }
      continue;
    }
    if (white == 0) {
      for (int i = 0; i < n; i += 1) {
        pt xx;
        xx.x = (x[i].x + x[i].y + 1) / 2;
        xx.y = (x[i].x - x[i].y + 1) / 2;
        x[i] = xx;
      }
      continue;
    }
    break;
  }
  vector<int> ans;
  for (int i = 0; i < n; i += 1) {
    if (abs(x[i].x + x[i].y) % 2) {
      ans.push_back(i + 1);
    }
  }
  cout << (ans.size()) << endl;
  for (int i = 0; i < ans.size(); i += 1) {
    cout << (ans[i]) << ' ';
  }
  cout << "" << '\n';
  return 0;
}