### BUGGY CODE ###

import sys
from itertools import combinations, permutations, product, combinations_with_replacement, accumulate
from heapq import heapify, heappop, heappush, heappushpop
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from math import sqrt, log, floor, ceil, factorial, cos, sin, pi#, gcd
from fractions import gcd
from operator import mul
from functools import reduce
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
LINF = 2**63-1
NIL = -LINF
MOD = 10**9+7
MGN = 4
def AST(exp: bool, msg: str = ""): assert exp, msg
def TAST(exp: bool, msg = ""):
    if exp is False: print("TAssertionError:", msg)
    while exp is False:
        pass
def II(): return int(input())
def IF(): return float(input())
def IS(): return input().replace('\n', '')
def ILCI(n: int): return [II() for _ in range(n)]
def ILCF(n: int): return [IF() for _ in range(n)]
def ILI(): return list(map(int, input().split()))
def ILLI(n: int): return [[int(j) for j in input().split()] for i in range(n)]
def ILF(): return list(map(float, input().split()))
def ILLF(n: int): return [[float(j) for j in input().split()] for i in range(n)]
def LTOS(lst: list, sep: str = ' '): return sep.join(map(str, lst))
def DEC(lst: list): return list(map(lambda x: x-1, lst))
def INC(lst: list): return list(map(lambda x: x+1, lst))

def xor_next(A: list) -> list:    
    N = len(A)
    res = []
    for i in range(N-1):
        res.append(A[i]^A[i+1])
    
    res.append(A[-1]^A[0])
    return res

def main():
    N = II()
    A = ILI()
    B = ILI()

    C = xor_next(A)
    D = xor_next(B)
    
    pos = []
    for k in range(N):
        if C[k:N] + C[0:k+N-N] == D:
            pos.append(k)

    ans = []
    for i in pos:
        ans.append((i, A[i] ^ B[0]))

    for e in ans:
        print(e[0], e[1])


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
from itertools import combinations, permutations, product, combinations_with_replacement, accumulate
from heapq import heapify, heappop, heappush, heappushpop
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from math import sqrt, log, floor, ceil, factorial, cos, sin, pi#, gcd
from fractions import gcd
from operator import mul
from functools import reduce
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
LINF = 2**63-1
NIL = -LINF
MOD = 10**9+7
MGN = 4
def AST(exp: bool, msg: str = ""): assert exp, msg
def TAST(exp: bool, msg = ""):
    if exp is False: print("TAssertionError:", msg)
    while exp is False:
        pass
def II(): return int(input())
def IF(): return float(input())
def IS(): return input().replace('\n', '')
def ILCI(n: int): return [II() for _ in range(n)]
def ILCF(n: int): return [IF() for _ in range(n)]
def ILI(): return list(map(int, input().split()))
def ILLI(n: int): return [[int(j) for j in input().split()] for i in range(n)]
def ILF(): return list(map(float, input().split()))
def ILLF(n: int): return [[float(j) for j in input().split()] for i in range(n)]
def LTOS(lst: list, sep: str = ' '): return sep.join(map(str, lst))
def DEC(lst: list): return list(map(lambda x: x-1, lst))
def INC(lst: list): return list(map(lambda x: x+1, lst))

def z_algo(S: str) -> list:
    N = len(S)
    if N == 0:
        return []
    ln = [0] * N
    ln[0] = N  
    i = 1
    w = 0
    while i < N:
        while i + w < N and S[w] == S[i + w]:
            w += 1
        ln[i] = w  
        if w == 0:
            i += 1
        else:
            j = 1
            while i + j < N and j + ln[j] < w:
                ln[i+j] = ln[j]
                j += 1
            i += j
            w -= j
    return ln

def z_algo_search(S: str, W: str) -> list:
    lens = z_algo(W+S)
    if len(lens) == 0:
        return []
    SL = len(S)
    WL = len(W)
    slens = lens[WL:]
    res = []
    for i in range(SL):
        if slens[i] >= WL:
            res.append(i)
    return res

def xor_next(A: list) -> list:    
    N = len(A)
    res = []
    for i in range(N-1):
        res.append(A[i]^A[i+1])
    
    res.append(A[-1]^A[0])
    return res

def main():
    N = II()
    A = ILI()
    B = ILI()

    C = xor_next(A)
    D = xor_next(B)

    # C の中から D を周期的にを探す
    pos = z_algo_search(C*2, D)
    pos = list(filter(lambda x: x < N, pos))
    
    ans = []
    for i in pos:
        ans.append((i, A[i] ^ B[0]))

    for e in ans:
        print(e[0], e[1])


if __name__ == '__main__':
    main()