use std::collections::BTreeSet;

fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());
    let n: usize = sc.read();

    let a: Vec<u64> = sc.vec(n);
    let b: Vec<u64> = sc.vec(n);
    let mut cs = vec![];
    for i in 0..31 {
        let b = b.iter().map(|&b| (b >> i) & 1).collect();
        let mut c = vec![];
        for j in 0..2 {
            let a = a.iter().map(|&a| ((a >> i) ^ j) & 1).collect();
            let cycles = cycles(&a, &b);
            c.push(cycles);
        }
        cs.push(c);
    }

    let mut ans = (0..n).map(|i| (i, 0)).collect::<Vec<_>>();
    for i in 0..31 {
        let mut next = vec![];
        for (k, x) in ans.into_iter() {
            for j in 0..2 {
                if !cs[i][j].contains(&k) {
                    continue;
                }
                next.push((k, x | (j << i)));
            }
        }
        ans = next;
    }

    let mut ans = ans
        .into_iter()
        .map(|(k, x)| ((n - k) % n, x))
        .collect::<Vec<_>>();
    ans.sort();
    for (k, x) in ans.into_iter() {
        sc.write(format!("{} {}\n", k, x));
    }
}

fn cycles(a: &Vec<u64>, b: &Vec<u64>) -> BTreeSet<usize> {
    let n = a.len();
    let mut array = vec![0; 3 * n];
    for i in 0..n {
        array[i] = a[i];
    }
    for i in 0..n {
        array[i + n] = b[i];
        array[i + 2 * n] = b[i];
    }

    let z_array = z_algorithm::calc_z_array(&array);
    let mut ans = BTreeSet::new();
    for k in 0..n {
        let length = z_array[n + k];
        if length >= n {
            ans.insert(k);
        }
    }
    ans
}

pub mod z_algorithm {
    pub fn calc_z_array<T: PartialEq>(s: &[T]) -> Vec<usize> {
        let n = s.len();
        let mut z_array = vec![0; n];

        // [l, r) is a window which matches with prefix of s
        let mut l = 0;
        let mut r = 1;
        for i in 1..n {
            if i >= r {
                l = i;
                r = i + 1;
                while r <= n && s[r - 1 - l] == s[r - 1] {
                    r += 1;
                }
                z_array[i] = r - l - 1;
                r -= 1;
            } else {
                if z_array[i - l] < r - i {
                    z_array[i] = z_array[i - l];
                } else {
                    l = i;
                    while r <= n && s[r - 1 - l] == s[r - 1] {
                        r += 1;
                    }
                    z_array[i] = r - l - 1;
                    r -= 1;
                }
            }
        }
        z_array[0] = n;
        z_array
    }
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> Self {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}


Measured memory_bytes: 163980