#include <bits/stdc++.h>
#include <boost/range/algorithm.hpp>
#include <boost/range/numeric.hpp>
#include <boost/integer/common_factor.hpp>
#include <boost/integer/common_factor_rt.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>

using std::string;
using std::vector;
using std::set;
using std::multiset;
using std::unordered_set;
using std::map;
using std::multimap;
using std::unordered_map;
using std::pair;
using std::cin;
using std::cout;

using boost::multiprecision::cpp_int;
using cpp_dec_float_1000 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000>>;

typedef uintmax_t    ull;
typedef intmax_t     ll;
typedef uint64_t     ul;
typedef uint32_t     ui;
typedef uint8_t      uc;

constexpr char CRLF  = '\n';
constexpr char SPACE = ' ';
constexpr char VECTOR_COUT_SEPARATOR = SPACE;
constexpr ll INF = 1000'000'007;
constexpr int MOD = 1000'000'007;

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> std::ostream& operator<< (std::ostream& os, const std::vector<T>& vc) { for(auto it = vc.begin(); it != vc.end(); ++it) { if (std::next(it) == vc.end()) os << *it; else os << *it << VECTOR_COUT_SEPARATOR; } return os; }
template<class T1, class T2> inline std::ostream & operator<< (std::ostream & os, const std::pair<T1, T2> & p) { return os << p.first << ' ' << p.second; }
template<class T> T modinv(T a, T m) { T b = m, u = 1, v = 0; while (b) { T t = a / b; a -= t * b; boost::swap(a, b); u -= t * v; boost::swap(u, v); } u %= m; if (u < 0) u += m; return u; }

template<class T>
struct KMP
{
public:
  /**
   * @param N strのサイズ
   * @param K wordのサイズ
   */
  KMP(int N, int K);

  /** 検索対象の文字列 */
  vector<T> str;

  /** 検索元の文字列 */
  vector<T> word;

  /** 内部処理で使用する検索テーブル */
  vector<size_t> memo;

  /**
   * 前計算処理を行う. 
   * 本APIを呼ぶ前にstr, wordに入力する必要がある.
   */
  void preCalc();

  /**
   * prePos番目以降で、wordと一致するstrの部分文字列が開始されるindexを返す.
   * 本APIを呼ぶ前にKMP::preCalcを実行する必要がある.
   * 
   * @param prePos 探索を始めるindex
   * @return pos 見つからなかった場合は-1
   */
  ssize_t find(ssize_t prePos);

  vector<int> findAll();
};

template<class T>
KMP<T>::KMP(int N, int K)
  : str(N)
  , word(K)
  , memo(K+1)
{}

template<class T>
void KMP<T>::preCalc()
{
  size_t i = 0;
  size_t j = 1;
  memo[0] = -1;
  while (j < word.size()) {
    auto isMatch = word[i] == word[j];
    if (!isMatch && i > 0) {
      i = memo[i];
    }
    else {
      if (isMatch) {
        ++i;
      }
      ++j;
      memo[j] = i;
    }
  }
  return;
}

template<class T>
ssize_t KMP<T>::find(ssize_t prePos)
{
  int i = prePos;
  int j = 0;
  while (i < (int)str.size() && j < (int)word.size()) {
    if (str[i] == word[j]) {
      ++i;
      ++j;
    }
    else if (j == 0) {
      ++i;
    }
    else {
      j = memo[j];
    }
  }
  return (j == (int)word.size()) ? (i - j) : -1;
}

template<class T>
vector<int> KMP<T>::findAll()
{
  vector<int> res{};

  int i = 0;
  int j = 0;
  while (i < (int)str.size() && j < (int)word.size()) {
    if (str[i] == word[j]) {
      ++i;
      ++j;
    }
    else if (j == 0) {
      ++i;
    }
    else {
      j = memo[j];
    }
    if (j == (int)word.size()) {
      res.push_back(i-j);
      j = memo[j];
    }
  }
  return std::move(res);
}

void solve(void)
{
  int N; cin >> N;
  vector<int> A(N), B(N);
  for (auto& a : A) {
    cin >> a;
  }
  for (auto& b : B) {
    cin >> b;
  }
  
  KMP<int> k(N*2, N);
  for (int i = 0; i < N; ++i) {
    k.str[i] = A[i] ^ A[(i+1) % N];
    k.word[i] = B[i] ^ B[(i+1) % N];
  }
  std::copy(k.str.begin(), k.str.begin()+N, k.str.begin()+N);
  k.preCalc();

  auto res = k.findAll();
  for (const auto& itr : res) {
    if (itr >= N) break;
    int i = 0;
    int j = (i + itr) % N;
    int x = B[i] ^ A[j];
    cout
      << itr << SPACE
      << x << CRLF;
  }
  // auto itr = k.find(0);
  // while (itr != -1 && itr < (int)A.size()) {
  //   int i = 0;
  //   int j = (i + itr) % N;
  //   int x = B[i] ^ A[j];
  //   cout
  //     << itr << SPACE
  //     << x << CRLF;

  //   itr = k.find(itr+1);
  // }

  return;
}

int main(void)
{
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(0);

  solve();

  return 0;
}


Measured memory_bytes: 9844