{-# OPTIONS_GHC -O2 #-}
{-# LANGUAGE BangPatterns #-}
import Data.Bits ((.&.),unsafeShiftL, unsafeShiftR)

import Control.Monad
import Control.Monad.ST
import Data.List
import qualified Data.ByteString.Char8 as B
import qualified Data.Vector.Unboxed as V
import qualified Data.Vector.Unboxed.Mutable as MV

main=do
  n<-readLn::IO Int
  as<-unfoldr (B.readInt.B.dropWhile(==' '))<$>B.getLine::IO[Int]
  bs<-unfoldr (B.readInt.B.dropWhile(==' '))<$>B.getLine::IO[Int]
  --
  print.sum.map (st n as bs) $ [0..28]
--

st::Int->[Int]->[Int]->Int->Int
st n as bs' k = if even$ sum $ map (\a->f n v k2 (a .&. km)) as then 0 else k2
  where
    k2 = unsafeShiftL 1 k
    km = (unsafeShiftL 1 (k+1)) - 1
    !v = bmod $ map (\b->b .&. km) bs'

bmod:: [Int]->V.Vector Int
bmod bs = runST $ do
  v <- V.thaw $ V.fromList bs
  sortv v 0 (MV.length v - 1)
  V.unsafeFreeze v
--
f::Int->V.Vector Int->Int->Int->Int
f n bs t a = b2 - b1 + n - b3
  where
    b1 = ubound bs (t-1-a) (-1,n)
    b2 = ubound bs ((unsafeShiftL t 1)-1-a) (-1,n)
    b3 = ubound bs ((unsafeShiftL t 2)-1-a) (-1,n)
--    b4 = ubound bs (4*t-1-a) (-1,n)

ubound v k (a,b)
    | a+1 == b = b
    | V.unsafeIndex v m <= k = ubound v k (m,b)
    | True = ubound v k (a,m)
    where m = unsafeShiftR (a+b) 1
--
{-# INLINE sortv #-}
sortv :: MV.STVector s Int -> Int -> Int -> ST s ()
sortv as b e = do
        l <- MV.unsafeRead as b
        r <- MV.unsafeRead as e
        p <- findP l (b+1) e
        case p of
            Nothing -> return ()
            Just piv -> do
                k <- partv as piv b e
                sortv as b (k-1)
                sortv as k e
    where
        findP a i e
            | i > e = return Nothing
            | True = do
                k <- MV.unsafeRead as i
                case (a < k, k < a) of
                    (True, _) -> return $ Just k
                    (_, True) -> return $ Just a
                    _ -> findP a (i+1) e

partv :: MV.STVector s Int -> Int -> Int -> Int -> ST s Int
partv as piv b e = do
    MV.unsafeSwap as b e
    l <- findF b
    r <- findT e
    if l <= r then partv as piv l r
              else return l
    where
        findF i = do
            k <- MV.unsafeRead as i
            if k < piv then findF (i+1) else return i
        findT j = do
            k <- MV.unsafeRead as j
            if k < piv then return j else findT (j-1)
