#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// cannot use count
// no move constructor (==> use pointer for merge tech)
// unordered_set by value: __gnu_pbds::null_type
// no erase(iterator)
#include <ext/pb_ds/assoc_container.hpp>
using __gnu_pbds::gp_hash_table;

// https://codeforces.com/blog/entry/62393
#include <chrono>
struct Hash {
  static uint64_t splitmix64(uint64_t x) {
    // http://xorshift.di.unimi.it/splitmix64.c
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM = std::chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
  size_t operator()(const pair<int, int> &a) const {
    return operator()((uint64_t)a.first << 32 | a.second);
  }
};
template <class K> using Set = gp_hash_table<K, __gnu_pbds::null_type, Hash>;
template <class K, class V> using Map = gp_hash_table<K, V, Hash>;


// a x + b y = (+/-) gcd(a, b)
//   (a, 0): g = a, x = 1, y = 0
//   (0, b), (b, b), (-b, b) (b != 0): g = b, x = 0, y = 1
//   otherwise: 2 |x| <= |b|, 2 |y| <= |a|
// S: signed integer
template <class S> S gojo(S a, S b, S &x, S &y) {
  if (b != 0) {
    const S g = gojo(b, a % b, y, x);
    y -= (a / b) * x;
    return g;
  } else {
    x = 1;
    y = 0;
    return a;
  }
}


pair<Int, Int> solve(int N, const vector<Int> &A, const vector<Int> &B) {
  Map<Int, int> freqB;
  auto check = [&](Int m, Int k) -> bool {
    Map<Int, int> freq;
    for (const Int a : A) {
      const Int b = (a + k) % m;
      auto it = freqB.find(b);
      if (it != freqB.end()) {
        if (++freq[b] > it->second) return false;
      } else {
        return false;
      }
    }
    return true;
  };
  
  __int128 sumA = 0;
  for (const Int a : A) {
    sumA += a;
  }
  Int sumB = 0, maxB = 0;
  for (const Int b : B) {
    sumB += b;
    chmax(maxB, b);
    ++freqB[b];
  }
  for (Int m = maxB + 1; ; ++m) {
    // sumA + N k == sumB  (mod m)
    Int x, y;
    const Int g = gojo<Int>(N, m, x, y);
    const Int m0 = m / g;
    if ((sumB - sumA) % g) continue;
    Int k0 = (__int128)x * ((sumB - sumA) / g % m0) % m0;
    if (k0 < 0) k0 += m0;
// cerr<<"m = "<<m<<", g = "<<g<<endl;
    for (Int k = k0; k < m; k += m0) {
// assert((sumA+(__int128)N*k-sumB)%m==0);
      if (check(m, k)) {
        return make_pair(m, k);
      }
    }
  }
}

void test(int N, Int M) {
  mt19937_64 rng(58);
  const Int K = rng() % M;
  vector<Int> A(N), B(N);
  for (int i = 0; i < N; ++i) {
    A[i] = 1 + rng() % 1'000'000'000'000'000'000LL;
    B[i] = (A[i] + K) % M;
    swap(B[rng() % (i + 1)], B[i]);
  }
  const auto ans = solve(N, A, B);
  cerr << "[test] " << N << " " << M << " " << K << ": " << ans << endl;
}

int main() {
  // test(2 * 83160, 10'000'000'000LL);
  
  int N;
  for (; ~scanf("%d", &N); ) {
    vector<Int> A(N), B(N);
    for (int i = 0; i < N; ++i) scanf("%lld", &A[i]);
    for (int i = 0; i < N; ++i) scanf("%lld", &B[i]);
    const auto ans = solve(N, A, B);
    printf("%lld %lld\n", ans.first, ans.second);
  }
  return 0;
}