//O(N^2)
#include <stdio.h>
#include <x86intrin.h>
typedef unsigned int uint;
#pragma GCC optimize ("O3")
void read(uint *p){
    int flag = 0;
    uint num = 0;
    for(;;){
        int c = getchar_unlocked() - '0';
        if(0 <= c && c <= 9){
            num = num*10+c;
            flag = 1;
        }else if(flag){
            *p=num;
            return;
        }
    }
}
#define N 200000
uint a[N] __attribute__ ((aligned (16)));
uint b[N] __attribute__ ((aligned (16)));
#pragma GCC optimize ("Ofast")
#pragma GCC target ("avx")
int main(void){
    uint ss[4];
    uint s=0;
    uint n;
    read(&n);
    for(uint i=0; i<n; i++){
        read(a+i);
    }
    for(uint i=0; i<n; i++){
        read(b+i);
    }
    if (n % 2) {
        for (uint i = 0; i < n; i++) s ^= a[i] ^ b[i];
    }
    __m128i s0 = _mm_setzero_si128();
    __m128i s1 = _mm_setzero_si128();
    __m128i s2 = _mm_setzero_si128();
    __m128i s3 = _mm_setzero_si128();
    uint j;
    for(j=0; j<N; j+=4){
        __m128i d = _mm_load_si128((__m128i*)(b+j));
        __m128i d0 = _mm_shuffle_epi32(d, 0x00);
        __m128i d1 = _mm_shuffle_epi32(d, 0x55);
        __m128i d2 = _mm_shuffle_epi32(d, 0xAA);
        __m128i d3 = _mm_shuffle_epi32(d, 0xFF);
        uint i;
        for(i=0; i<N; i+=16){
            __m128i c0 = _mm_load_si128((__m128i*)(a+i+0));
            __m128i c1 = _mm_load_si128((__m128i*)(a+i+4));
            __m128i c2 = _mm_load_si128((__m128i*)(a+i+8));
            __m128i c3 = _mm_load_si128((__m128i*)(a+i+12));
            __m128i t0 = _mm_add_epi32(c0, d0);
            __m128i t1 = _mm_add_epi32(c1, d0);
            __m128i t2 = _mm_add_epi32(c2, d0);
            __m128i t3 = _mm_add_epi32(c3, d0);
            s0 = _mm_xor_si128(s0, t0);
            s1 = _mm_xor_si128(s1, t1);
            s2 = _mm_xor_si128(s2, t2);
            s3 = _mm_xor_si128(s3, t3);
            t0 = _mm_add_epi32(c0, d1);
            t1 = _mm_add_epi32(c1, d1);
            t2 = _mm_add_epi32(c2, d1);
            t3 = _mm_add_epi32(c3, d1);
            s0 = _mm_xor_si128(s0, t0);
            s1 = _mm_xor_si128(s1, t1);
            s2 = _mm_xor_si128(s2, t2);
            s3 = _mm_xor_si128(s3, t3);
            t0 = _mm_add_epi32(c0, d2);
            t1 = _mm_add_epi32(c1, d2);
            t2 = _mm_add_epi32(c2, d2);
            t3 = _mm_add_epi32(c3, d2);
            s0 = _mm_xor_si128(s0, t0);
            s1 = _mm_xor_si128(s1, t1);
            s2 = _mm_xor_si128(s2, t2);
            s3 = _mm_xor_si128(s3, t3);
            t0 = _mm_add_epi32(c0, d3);
            t1 = _mm_add_epi32(c1, d3);
            t2 = _mm_add_epi32(c2, d3);
            t3 = _mm_add_epi32(c3, d3);
            s0 = _mm_xor_si128(s0, t0);
            s1 = _mm_xor_si128(s1, t1);
            s2 = _mm_xor_si128(s2, t2);
            s3 = _mm_xor_si128(s3, t3);
        }
        /*
        for(; i<n; i++){
            s ^= a[i]+b[j+0];
            s ^= a[i]+b[j+1];
            s ^= a[i]+b[j+2];
            s ^= a[i]+b[j+3];
        }
        */
    }
    /*
    for(; j<n; j++){
        for(uint i=0; i<n; i++){
            s ^= a[i]+b[j];
        }
    }
    */
    s0 = _mm_xor_si128(s0, s2);
    s1 = _mm_xor_si128(s1, s3);
    s0 = _mm_xor_si128(s0, s1);
    _mm_storeu_si128((__m128i*)ss, s0);
    ss[0] ^= ss[2];
    ss[1] ^= ss[3];
    ss[0] ^= ss[1];
    printf("%u\n", ss[0]^s);
    return 0;
}


Measured memory_bytes: 1664