/**
 * @file qoj5533-1.cpp
 * @author n685
 * @brief
 * @date 2024-04-12
 *
 *
 */
#include <bits/stdc++.h>

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbgR(...) 4242
#define dbgP(...) 420
#define dbgRP(...) 420420
void nline() {}
#endif

template <class T> constexpr std::pair<T, T> exEucl(T a, T b) {
  if (a < b) {
    // auto [x, y] = exEucl(b, a);
    T x, y;
    std::tie(x, y) = exEucl(b, a);
    return {y, x};
  }
  if (b == 0) {
    assert(a == 1);
    return {1, 0};
  }
  // auto [x, y] = exEucl(b, a % b);
  T x, y;
  std::tie(x, y) = exEucl(b, a % b);
  return {y, x - (a / b) * y};
}
template <
    class T, class U,
    typename std::enable_if<std::is_integral<U>::value, bool>::type = true>
constexpr T binpow(T a, U b) {
  // 0^0 = 1
  T res = 1;
  while (b > 0) {
    if (b % 2 == 1) {
      res *= a;
    }
    a *= a;
    b /= 2;
  }
  return res;
}

template <class Md, class V = int64_t> struct Mod {
  using T = typename std::decay<decltype(Md::value)>::type;
  T val = 0;

  template <class U> static constexpr T normalize(U val) {
    if (val <= -Md::value || Md::value <= val) {
      val %= Md::value;
    }
    if (val < 0) {
      val += Md::value;
    }
    return static_cast<T>(val);
  }

  constexpr Mod() : val(0) {}
  template <class U, typename std::enable_if<std::is_integral<U>::value,
                                             bool>::type = true>
  constexpr Mod(U _val) {
    val = normalize(_val);
  }

  // addition
  constexpr Mod &operator+=(Mod b) {
    val += b.val;
    if (val >= Md::value) {
      val -= Md::value;
    }
    return *this;
  }
  friend constexpr Mod operator+(Mod a, Mod b) { return (a += b); }
  constexpr Mod &operator++() { return (*this += 1); }
  constexpr Mod operator++(int) {
    Mod res = *this;
    ++(*this);
    return res;
  }

  // subtraction
  constexpr Mod &operator-=(Mod b) {
    val -= b.val;
    if (val < 0) {
      val += Md::value;
    }
    return *this;
  }
  friend constexpr Mod operator-(Mod a, Mod b) { return (a -= b); }
  constexpr Mod &operator--() { return (*this -= 1); }
  constexpr Mod operator--(int) {
    Mod res = *this;
    --(*this);
    return res;
  }

  // multiplication
  constexpr Mod &operator*=(Mod b) {
    val = static_cast<T>(static_cast<V>(val) * b.val % Md::value);
    return *this;
  }
  friend constexpr Mod operator*(Mod a, Mod b) { return (a *= b); }

  template <class U> constexpr Mod binpow(U b) const {
    return ::binpow(*this, b);
  }
  constexpr Mod inv() const {
    return Mod(exEucl(static_cast<V>(val), static_cast<V>(Md::value)).first);
    // return binpow(Md::value - 2);
  }

  // comparison
  constexpr bool operator==(Mod b) const { return (val == b.val); }
  // constexpr auto operator<=>(const Mod &b) const = default;
  constexpr bool operator!=(Mod b) const { return (val != b.val); }
  constexpr bool operator<(Mod b) const { return (val < b.val); }
  constexpr bool operator>(Mod b) const { return (val > b.val); }
  constexpr bool operator<=(Mod b) const { return (val <= b.val); }
  constexpr bool operator>=(Mod b) const { return (val >= b.val); }

  // io
  friend std::istream &operator>>(std::istream &in, Mod &a) {
    V v;
    in >> v;
    a = Mod(v);
    return in;
  }
  friend std::ostream &operator<<(std::ostream &out, const Mod &a) {
    out << a.val;
    return out;
  }

  // conversion
  explicit constexpr operator T() const { return val; }
  constexpr const T &operator()() const { return val; }
  constexpr Mod operator-() const { return Mod(-val); }
};

struct Md {
  static int value;
};
int Md::value;
using Mint = Mod<Md>;

void solve(const int r) {
  int n;
  std::cin >> n;
  Md::value = 2 * n + 1;
  std::vector<std::pair<int, int>> diff(2 * n + 1);
  auto ins = [&](int a, int b) { diff[Mint(b - a)()] = {a, b}; };
  if (n % 2 == 0) {
    for (int i = 1; i <= n - 1; ++i) {
      ins(2 * n - i + 1, i);
    }
  } else {
    for (int i = 1; i <= n - 1; ++i) {
      ins(i, 2 * n - i + 1);
    }
  }
  ins(0, 2 * n);
  ins(0, 1);
  ins(n, 2);
  ins(n, 2 * n - 1);
  ins(4, n + 1);
  ins(2 * n - 3, n + 1);

  if (r == 1 || r == 2) {
    std::set<int> s;
    int sum = 0;
    for (int i = 0; i < n; ++i) {
      int v;
      std::cin >> v;
      s.insert(v);
      sum = (sum + v) % (2 * n + 1);
    }
    for (auto [a, b] : diff) {
      if (a == b) {
        continue;
      }
      if (s.contains(Mint(a + sum)()) && s.contains(Mint(b + sum)())) {
        std::cout << Mint(a + sum)() << ' ' << Mint(b + sum)() << '\n';
        return;
      }
    }
  } else {
    int a1, a2;
    std::cin >> a1 >> a2;
    int b1, b2;
    std::cin >> b1 >> b2;
    auto slv = [&](int a, int b) -> int {
      int d = Mint(b - a)();
      return Mint(a - diff[d].first)();
    };
    int s1 = slv(a1, a2);
    int s2 = slv(b1, b2);
    std::cout << Mint(-s1 - s2) << '\n';
  }
}

int main() {
#ifndef LOCAL
  std::cin.tie(nullptr)->sync_with_stdio(false);
#endif

  int t, r;
  std::cin >> t >> r;
  while (t--) {
    solve(r);
  }
}