#include "explore.h"

#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


unsigned xrand() {
  static unsigned x = 314159265, y = 358979323, z = 846264338, w = 327950288;
  unsigned t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
}


int N, M;

int E;
vector<int> xs;
void getXs() {
  E = (31 - __builtin_clz(N)) + 1;
  xs.assign(N, 0);
  for (int e = 0; e < E; ++e) {
    for (int u = 0; u < N; ++u) if (u >> e & 1) {
      modify(u);
    }
    for (int u = 0; u < N; ++u) {
      xs[u] |= query(u) << e;
    }
  }
  for (int u = 0; u < N; ++u) {
    xs[u] ^= xs[u] << 1;
    xs[u] &= ~(1 << E);
  }
}


void run0() {
  vector<int> now(N, 0);
  for (int u = 0; u < N - 1; ++u) {
    modify(u);
    for (int v = u + 1; v < N; ++v) {
      const int res = query(v);
      if (now[v] ^ res) {
        report(u, v);
      }
      now[v] = res;
    }
  }
}

void runA() {
  getXs();
  for (int u = 0; u < N; ++u) {
    const int v = xs[u] ^ u;
    if (u < v) {
      report(u, v);
    }
  }
}

void runB() {
  getXs();
  for (int u = N; --u > 0; ) {
    const int p = xs[u] ^ u;
    report(p, u);
    xs[p] ^= u;
  }
}

void runC() {
  getXs();
  vector<int> now(N, 0);
  for (int u = 0; u < N; ++u) {
    now[u] = __builtin_parity(xs[u]);
  }
  modify(0);
  vector<int> us;
  for (int u = 1; u < N; ++u) {
    if (now[u] ^ query(u)) {
      us.push_back(u);
    }
  }
  assert(us.size() <= 2);
  for (const int u : us) {
    int v = 0, w = u;
    for (; ; ) {
      report(v, w);
      const int x = xs[w] ^ v ^ w;
      if (!x) {
        break;
      }
      v = w;
      w = x;
    }
  }
}

void runD() {
  getXs();
  set<pair<int, int>> used;
  auto ae = [&](int u, int v) -> void {
    if (used.insert(minmax(u, v)).second) {
      xs[u] ^= v;
      xs[v] ^= u;
      report(u, v);
    }
  };
  queue<int> que;
  for (int u = 0; u < N; ++u) {
    que.push(u);
  }
  for (; !que.empty(); ) {
    const int u = que.front();
    que.pop();
    const int v = xs[u] ^ u;
    if (0 <= v && v < N && u != v) {
      const int res0 = query(u);
      modify(v);
      const int res1 = query(u);
      if (res0 ^ res1) {
        ae(u, v);
        if (check(u)) {
          que.push(v);
        }
      }
    }
  }
}

void run4() {
  for (int u = 0; u < N; ++u) {
    modify(u);
  }
  vector<int> deg(N);
  for (int u = 0; u < N; ++u) {
    deg[u] = query(u) ^ 1;
  }
  for (int u = 0; u < N; ++u) {
    set<int> vis;
    for (; deg[u] || !check(u); ) {
      vector<int> vs;
      for (int v = u + 1; v < N; ++v) if (!vis.count(v)) {
        vs.push_back(v);
      }
      assert(vs.size() >= 1);
      int last = query(u);
      for (; ; ) {
        const int vsLen = vs.size();
        if (vsLen == 1) {
          break;
        }
        for (int j = 0; j < vsLen; ++j) {
          swap(vs[xrand() % (j + 1)], vs[j]);
        }
        const int half = vsLen / 2;
        for (int j = 0; j < half; ++j) {
          modify(vs[j]);
        }
        const int res = query(u);
        if (last ^ res) {
          vs.resize(half);
        } else if (deg[u]) {
          vs.erase(vs.begin(), vs.begin() + half);
        } else {
          // retry
        }
        last = res;
      }
      {
        const int v = vs[0];
        deg[u] ^= 1;
        deg[v] ^= 1;
        vis.insert(v);
        report(u, v);
      }
    }
  }
}

// ayashii for many isolated points
void run() {
  set<int> yet;
  for (int u = 0; u < N; ++u) {
    yet.insert(u);
  }
  set<pair<int, int>> used;
  auto ae = [&](int u, int v) -> void {
    if (used.insert(minmax(u, v)).second) {
      report(u, v);
      if (check(u)) yet.erase(u);
      if (check(v)) yet.erase(v);
    }
  };
  vector<int> now(N, 0), onV(N, 0);
  for (; (int)used.size() < M; ) {
    const vector<int> us(yet.begin(), yet.end());
    vector<int> vs;
    for (const int u : us) if (xrand() & 1) vs.push_back(u);
    for (const int v : vs) onV[v] = 1;
    for (const int u : us) now[u] = query(u);
    for (const int v : vs) modify(v);
    vector<int> ws;
    for (const int u : us) if (now[u] ^ query(u) ^ onV[u]) {
      now[u] ^= onV[u] ^ 1;
      ws.push_back(u);
    }
    const int vsLen = vs.size();
    const int wsLen = ws.size();
    vector<int> los(wsLen, 0), his(wsLen, vsLen);
    for (; ; ) {
      bool upd = false;
      vector<vector<int>> kss(vsLen);
      for (int k = 0; k < wsLen; ++k) if (los[k] + 1 != his[k]) {
        upd = true;
        kss[(los[k] + his[k]) / 2].push_back(k);
      }
      if (!upd) break;
      for (int j = 0; j < vsLen; ++j) {
        for (const int k : kss[j]) {
          int diff = now[ws[k]] ^ query(ws[k]);
          if (onV[ws[k]] && ws[k] < vs[j]) {
            diff ^= 1;
          }
          (diff ? his[k] : los[k]) = j;
        }
        modify(vs[j]);
      }
      for (const int w : ws) {
        now[w] ^= onV[w] ^ 1;
      }
    }
    for (int k = 0; k < wsLen; ++k) {
      ae(vs[los[k]], ws[k]);
    }
    for (const int v : vs) onV[v] = 0;
  }
}

void explore(int N_, int M_) {
  N = N_;
  M = M_;
  switch (N % 10) {
    case 8: runA(); break;
    case 7: runB(); break;
    case 6: runC(); break;
    case 5: runD(); break;
    case 4: run4(); break;
    default: {
      if (N <= 500) {
        run0();
      } else {
        run();
      }
    }
  }
}