#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>


char getChar() {
  const int L = 10000000;
  static char buf[L], *p = buf, *end = buf;
  if (p == end) {
    if (feof(stdin)) return -1;
    end = buf + fread(p = buf, 1, L, stdin);
  }
  return *(p++);
}

int readInt() {
  int ans = 0, c, f = 1;
  while (!isdigit(c = getChar()))
    if (c == '-') f = -1;
  do ans = ans * 10 + c - '0';
  while (isdigit(c = getChar()));
  return ans * f;
}

inline int abs(int x) { return x < 0 ? -x : x; }

const int N = 1050;
const int M = (int)(1.5 * N);

struct NComp {
  int r, i;
  // (a + bi) * {1, -1, i, -i}
  // a > 0, b >= 0 OR a = b = 0
  NComp(int x = 0, int y = 0) {
    // x + yi; -y+xi; -x-yi; y-xi
    if (x == 0 || x * y < 0) std::swap(x, y);
    r = abs(x);
    i = abs(y);
  }

  inline friend int Abs(const NComp &x) {
    return x.r * x.r + x.i * x.i;
  }

  inline friend bool operator<(const NComp &a, const NComp &b) {
    int la = Abs(a), lb = Abs(b);
    return la == lb ? a.r < b.r : la < lb;
  }

  inline friend bool operator==(const NComp &a, const NComp &b) {
    return a.r == b.r && a.i == b.i;
  }

  inline friend NComp operator*(const NComp &a, const NComp &b) {
    return NComp(a.r * b.r - a.i * b.i, a.r * b.i + b.r * a.i);
  }
};

NComp T[M * M], Pr[M * M];
int minP[M][M], d[M][M], ld[M][M];
int S[N][N];

void Sieve(int n) {
  int K = n * n * 2, s = 0, pr_cnt = 0;
  d[1][0] = 1;
  for (int i = 1; i * i <= K; ++i)
    for (int j = 0, t = K - i * i; j * j <= t; ++j)
      T[s++] = NComp(i, j);
  std::sort(T, T + s);
  for (int i = 1; i < s; ++i) { // T[0] = 1+0i
  NComp x = T[i];
    if (!minP[x.r][x.i]) {
      Pr[minP[x.r][x.i] = ++pr_cnt] = x;
      ld[x.r][x.i] = 1;
      d[x.r][x.i] = 2;
    }
    int t = minP[x.r][x.i], q = d[x.r][x.i];
    for (int j = 1; j <= t; ++j) {
      NComp y = x * Pr[j];
      if (Abs(y) > K) break;
      minP[y.r][y.i] = j;
      ld[y.r][y.i] = q;
      d[y.r][y.i] = j == t ? q * 2 - ld[x.r][x.i] : q * 2;
    }
  }
  for (int i = 0; i <= n; ++i) {
    S[0][i] = 0;
    S[i][0] = (i ? S[i - 1][0] : 0) + d[i][0];
  }
  for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= n; ++j)
      S[i][j] = S[i - 1][j] + S[i][j - 1] - S[i - 1][j - 1] + d[i][j];
}

int get(int a, int b) {
  if (a >= 0) {
    if (b >= 0) return S[a][b] - S[a][0];
    else return -S[a][-(b + 1)];
  } else {
    if (b >= 0) return -S[b][-(a + 1)];
    else return S[-(a + 1)][-(b + 1)] + S[-(b + 1)][0];
  }
}

int main() {
  Sieve(1000);
  int T = readInt();
  int ans = 0;
  while (T--) {
    int a = readInt() - 1, b = readInt(), c = readInt() - 1, d = readInt();
    ans ^= (get(b, d) - get(a, d) - get(b, c) + get(a, c));
    // printf("%d\n", (get(b, d) - get(a, d) - get(b, c) + get(a, c)) << 2);
  }
  printf("%d\n", ans << 2);
  return 0;
}