#include <bits/stdc++.h>
struct MI {
 private:
  char bb[1 << 14];
  FILE *f;
  char *bs, *be;
  char e;
  bool o, l;

 public:
  MI() : f(stdin), bs(0), be(0) {}
  inline char get() {
    if (o) {
      o = 0;
      return e;
    }
    if (bs == be) be = (bs = bb) + fread(bb, 1, sizeof(bb), f);
    if (bs == be) {
      l = 1;
      return -1;
    };
    return *bs++;
  }
  inline void unget(char c) {
    o = 1;
    e = c;
  }
  template <class T>
  inline MI &operator>(T &);
};
template <class T>
struct Q {
  const static bool U = T(-1) >= T(0);
  inline void operator()(MI &t, T &r) const {
    r = 0;
    char c;
    bool y = 0;
    if (U)
      for (;;) {
        c = t.get();
        if (c == -1) goto E;
        if (isdigit(c)) break;
      }
    else
      for (;;) {
        c = t.get();
        if (c == -1) goto E;
        if (c == '-') {
          c = t.get();
          if (isdigit(c)) {
            y = 1;
            break;
          };
        } else if (isdigit(c))
          break;
        ;
      };
    for (;;) {
      if (c == -1) goto E;
      if (isdigit(c))
        r = r * 10 + (c ^ 48);
      else
        break;
      c = t.get();
    }
    t.unget(c);
  E:;
    if (y) r = -r;
  }
};
template <>
struct Q<char> {};
template <class T>
inline MI &MI::operator>(T &t) {
  Q<T>()(*this, t);
  return *this;
}
template <class T>
std::ostream &operator<(std::ostream &out, const T &t) {
  return out << t;
}
using std::cout;
MI cin;
const int $n = 500005;
const int $v = $n * 2;
int n, vs[$v], vt, deg[$v], f[$v], sup[$n][2];
bool e[$n];
std::vector<int> path;
std::vector<std::pair<int, int>> outs[$v];
std::map<std::pair<int, int>, std::vector<int>> wut;
struct {
  int a, b;
} v[$n];
int getf(int x) { return f[x] == x ? x : (f[x] = getf(f[x])); }
void dfs(int x) {
  auto &cur = outs[x];
  while (!cur.empty()) {
    auto [id, v] = cur.back();
    cur.pop_back();
    if (e[id]) continue;
    e[id] = 1;
    dfs(v);
  }
  path.push_back(x);
}
inline std::pair<int, int> key(int x, int y) {
  if (x > y) std::swap(x, y);
  return {x, y};
}
inline bool check(int l) {
  const int M = (1 << l) - 1;
  vt = 0;
  for (auto __r = (n), i = (1); i <= __r; ++i) {
    vs[++vt] = v[i].a & M;
    vs[++vt] = v[i].b & M;
  }
  std::sort(vs + 1, vs + vt + 1);
  vt = std::unique(vs + 1, vs + vt + 1) - vs - 1;
  auto find = [](int x) -> int {
    return std::lower_bound(vs + 1, vs + vt + 1, x) - vs;
  };
  for (auto __r = (vt), i = (1); i <= __r; ++i) {
    deg[i] = 0;
    f[i] = i;
  }
  for (auto __r = (n), i = (1); i <= __r; ++i) {
    const auto x = find(v[i].a & M), y = find(v[i].b & M);
    ++deg[x];
    ++deg[y];
    f[getf(x)] = getf(y);
  }
  bool c = 0;
  for (auto __r = (vt), i = (1); i <= __r; ++i) {
    if (deg[i] & 1) return 0;
    if (f[i] == i) {
      if (c)
        return 0;
      else
        c = 1;
    }
  }
  return 1;
}
int main() {
  cin > n;
  for (auto __r = (n), i = (1); i <= __r; ++i) cin > v[i].a > v[i].b;
  int l = 1, r = 20, ret = 0;
  while (l <= r) {
    const auto mid = (l + r) >> 1;
    if (check(mid))
      l = (ret = mid) + 1;
    else
      r = mid - 1;
  }
  cout < ret < ('\n');
  const int M = (1 << ret) - 1;
  vt = 0;
  for (auto __r = (n), i = (1); i <= __r; ++i) {
    e[i] = 0;
    vs[++vt] = v[i].a & M;
    vs[++vt] = v[i].b & M;
  }
  std::sort(vs + 1, vs + vt + 1);
  vt = std::unique(vs + 1, vs + vt + 1) - vs - 1;
  auto find = [](int x) -> int {
    return std::lower_bound(vs + 1, vs + vt + 1, x) - vs;
  };
  wut.clear();
  for (auto __r = (vt), i = (1); i <= __r; ++i) {
    deg[i] = 0;
    outs[i].clear();
  }
  for (auto __r = (n), i = (1); i <= __r; ++i) {
    const auto x = sup[i][0] = find(v[i].a & M),
               y = sup[i][1] = find(v[i].b & M);
    outs[x].emplace_back(i, y);
    outs[y].emplace_back(i, x);
    wut[key(x, y)].push_back(i);
  }
  dfs(1);
  for (int i = 1; i < path.size(); ++i) {
    auto &cur = wut[key(path[i], path[i - 1])];
    assert(!cur.empty());
    const auto id = cur.back();
    cur.pop_back();
    if (sup[id][0] == path[i - 1])
      cout < (id * 2 - 1) < ' ' < (id * 2) < ' ';
    else
      cout < (id * 2) < ' ' < (id * 2 - 1) < ' ';
  }
  cout < ('\n');
  return 0;
}
