#if __INCLUDE_LEVEL__ == 0

#include <bits/stdc++.h>

using namespace std;

#include __BASE_FILE__

namespace {

void solve() {
  int n;
  cin >> n;
  vector<tuple<int, int, int>> ans;
  set<pair<int, int>> se;
  for (int i : rep(n)) {
    se.emplace(i, i + 1);
  }
  auto add = [&](int a, int b, int c) {
    if (n < c) {
      return;
    }
    if (se.contains({a, c})) {
      return;
    }
    assert(se.contains({a, b}));
    assert(se.contains({b, c}));
    ans.emplace_back(a, b, c);
    se.emplace(a, c);
  };
  for (int o = 0; o < 1 << 16; o += 16) {
    for (int p = o + 4; p < o + 16; p += 4) {
      for (int w : rep1(2, 4)) {
        add(p - w, p - w + 1, p);
        add(p, p + w - 1, p + w);
      }
    }
    add(o + 4, o + 8, o + 12);
  }
  for (int o = 0; o < 1 << 16; o += 256) {
    for (int p = o + 16; p < o + 256; p += 16) {
      for (int w : rep1(2, 16)) {
        add(p - w, p - w + 1, p);
        add(p, p + w - 1, p + w);
      }
    }
    for (int r = 48; r < 256; r += 16) {
      for (int l = r - 32; 16 <= l; l -= 16) {
        add(o + l, o + r - 16, o + r);
      }
    }
  }
  for (int p = 256; p < 1 << 16; p += 256) {
    for (int w : rep1(2, 256)) {
      add(p - w, p - w + 1, p);
      add(p, p + w - 1, p + w);
    }
  }
  for (int r = 256 * 3; r < 1 << 16; r += 256) {
    for (int l = r - 256 * 2; 256 <= l; l -= 256) {
      add(l, r - 256, r);
    }
  }
  print(ssize(ans));
  for (auto [a, b, c] : ans) {
    print(a, b, c);
  }
  int q;
  cin >> q;
  while (q--) {
    int l, r;
    cin >> tie(l, r);
    auto path = [&]() -> vector<int> {
      if (se.contains({l, r})) {
        return {l, r};
      }
      int l256 = (l / 256 + 1) * 256;
      int r256 = (r - 1) / 256 * 256;
      if (l256 <= r256) {
        return {l, l256, r256, r};
      }
      int l16 = (l / 16 + 1) * 16;
      int r16 = (r - 1) / 16 * 16;
      if (l16 <= r16) {
        return {l, l16, r16, r};
      }
      int l4 = (l / 4 + 1) * 4;
      int r4 = (r - 1) / 4 * 4;
      if (l4 <= r4) {
        return {l, l4, r4, r};
      }
      return ALL(vector, rep1(l, r));
    }();
    ALL(path.erase, ranges::unique(path));
    print(path);
    assert(ssize(path) <= 4);
    for (int i : rep(1, ssize(path))) {
      assert(se.contains({path[i - 1], path[i]}));
    }
  }
}

}  // namespace

int main() {
  ios::sync_with_stdio(false);

  solve();
}

#else  // __INCLUDE_LEVEL__

#undef assert
#define assert(expr) (expr) || (__builtin_unreachable(), 0)

#define ALL(f, r, ...) \
  [&](auto&& _) { return f(begin(_), end(_), ##__VA_ARGS__); }(r)

template <class T, class U = T>
bool chmin(T& x, U&& y) {
  return y < x && (x = forward<U>(y), true);
}

template <class T, class U = T>
bool chmax(T& x, U&& y) {
  return x < y && (x = forward<U>(y), true);
}

namespace std {

template <class T1, class T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
  return is >> p.first >> p.second;
}

template <class... Ts>
istream& operator>>(istream& is, tuple<Ts...>& t) {
  return apply([&is](auto&... xs) -> istream& { return (is >> ... >> xs); }, t);
}

template <class... Ts>
istream& operator>>(istream& is, tuple<Ts&...>&& t) {
  return is >> t;
}

template <class R, enable_if_t<!is_convertible_v<R, string>>* = nullptr>
auto operator>>(istream& is, R&& r) -> decltype(is >> *begin(r)) {
  for (auto&& e : r) {
    is >> e;
  }
  return is;
}

template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
  return os << p.first << ' ' << p.second;
}

template <class... Ts>
ostream& operator<<(ostream& os, const tuple<Ts...>& t) {
  auto f = [&os](const auto&... xs) -> ostream& {
    [[maybe_unused]] auto sep = "";
    ((os << exchange(sep, " ") << xs), ...);
    return os;
  };
  return apply(f, t);
}

template <class R, enable_if_t<!is_convertible_v<R, string_view>>* = nullptr>
auto operator<<(ostream& os, R&& r) -> decltype(os << *begin(r)) {
  auto sep = "";
  for (auto&& e : r) {
    os << exchange(sep, " ") << e;
  }
  return os;
}

}  // namespace std

template <class... Ts>
void print(Ts&&... xs) {
  cout << tie(xs...) << '\n';
}

inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }
inline auto per(int l, int r) { return rep(l, r) | views::reverse; }
inline auto per(int n) { return per(0, n); }
inline auto per1(int l, int r) { return per(l, r + 1); }
inline auto per1(int n) { return per(1, n + 1); }

#endif  // __INCLUDE_LEVEL__