Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np


def main():
    N = int(input())
    A = np.array(list(map(int, input().split())))
    B = np.array(list(map(int, input().split())))
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = np.sort(B % (2 * pow_2_k))
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        for a in MA:
            index_1 = np.searchsorted(MB, pow_2_k - a, side='left')
            index_2 = np.searchsorted(MB, 2 * pow_2_k - a, side='left')
            index_3 = np.searchsorted(MB, 3 * pow_2_k - a, side='left')
            cnt += (N - index_1) - (N - index_2) + (N - index_3)
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    print(ans)


if __name__ == '__main__':
    main()

Fixed submission:
import numpy as np


def main():
    N = int(input())
    A = np.array(list(map(int, input().split())))
    B = np.array(list(map(int, input().split())))
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = B % (2 * pow_2_k)
        MB.sort()
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        indices_1 = np.searchsorted(MB, pow_2_k - MA, side='left')
        indices_2 = np.searchsorted(MB, 2 * pow_2_k - MA, side='left')
        indices_3 = np.searchsorted(MB, 3 * pow_2_k - MA, side='left')
        cnt += ((N - indices_1) - (N - indices_2) + (N - indices_3)).sum()
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    print(ans)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np


def simple_solution(N, A, B):
    ret = 0
    for a in A:
        for b in B:
            ret ^= a + b
    return ret


def solution(N, A, B):
    pow_2_k = 1
    ans = 0
    A = np.array(A)
    B = np.array(B)
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = np.sort(B % (2 * pow_2_k))
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        for a in MA:
            index_1 = np.searchsorted(MB, pow_2_k - a, side='left')
            index_2 = np.searchsorted(MB, 2 * pow_2_k - a, side='left')
            index_3 = np.searchsorted(MB, 3 * pow_2_k - a, side='left')
            cnt += (N - index_1) - (N - index_2) + (N - index_3)
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    return ans


def check():
    import random
    random.seed(0)
    for N in range(1, 101):
        A = random.choices(range(2 ** 28), k=N)
        B = random.choices(range(2 ** 28), k=N)
        print('Checking the case with size: {}'.format(N))
        assert simple_solution(N, A, B) == solution(N, A, B)
    print('OK')


def main():
    N = int(input())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))
    print(solution(N, A, B))


if __name__ == '__main__':
    main()
    # check()

Fixed submission:
import numpy as np


def main():
    N = int(input())
    A = np.array(list(map(int, input().split())))
    B = np.array(list(map(int, input().split())))
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = B % (2 * pow_2_k)
        MB.sort()
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        indices_1 = np.searchsorted(MB, pow_2_k - MA, side='left')
        indices_2 = np.searchsorted(MB, 2 * pow_2_k - MA, side='left')
        indices_3 = np.searchsorted(MB, 3 * pow_2_k - MA, side='left')
        cnt += ((N - indices_1) - (N - indices_2) + (N - indices_3)).sum()
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    print(ans)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
def simple_solution(N, A, B):
    ret = 0
    for a in A:
        for b in B:
            ret ^= a + b
    return ret


def solution(N, A, B):
    import numpy as np
    pow_2_k = 1
    ans = 0
    A = np.array(A)
    B = np.array(B)
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = np.sort(B % (2 * pow_2_k))
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        for a in MA:
            index_1 = np.searchsorted(MB, pow_2_k - a, side='left')
            index_2 = np.searchsorted(MB, 2 * pow_2_k - a, side='left')
            index_3 = np.searchsorted(MB, 3 * pow_2_k - a, side='left')
            cnt += (N - index_1) - (N - index_2) + (N - index_3)
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    return ans


def check():
    import random
    random.seed(0)
    for N in range(1, 101):
        A = random.choices(range(2 ** 28), k=N)
        B = random.choices(range(2 ** 28), k=N)
        print('Checking the case with size: {}'.format(N))
        assert simple_solution(N, A, B) == solution(N, A, B)
    print('OK')


def main():
    N = int(input())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))
    print(solution(N, A, B))


if __name__ == '__main__':
    main()
    # check()

Fixed submission:
import numpy as np


def main():
    N = int(input())
    A = np.array(list(map(int, input().split())))
    B = np.array(list(map(int, input().split())))
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = B % (2 * pow_2_k)
        MB.sort()
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        indices_1 = np.searchsorted(MB, pow_2_k - MA, side='left')
        indices_2 = np.searchsorted(MB, 2 * pow_2_k - MA, side='left')
        indices_3 = np.searchsorted(MB, 3 * pow_2_k - MA, side='left')
        cnt += ((N - indices_1) - (N - indices_2) + (N - indices_3)).sum()
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    print(ans)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
def simple_solution(N, A, B):
    ret = 0
    for a in A:
        for b in B:
            ret ^= a + b
    return ret


def solution(N, A, B):
    import bisect
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = [a % (2 * pow_2_k) for a in A]
        MB = [b % (2 * pow_2_k) for b in B]
        MB.sort()
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        for a in MA:
            index_1 = bisect.bisect_left(MB, pow_2_k - a)
            index_2 = bisect.bisect_left(MB, 2 * pow_2_k - a)
            index_3 = bisect.bisect_left(MB, 3 * pow_2_k - a)
            cnt += (N - index_1) - (N - index_2) + (N - index_3)
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    return ans


def check():
    import random
    random.seed(0)
    for N in range(1, 101):
        A = random.choices(range(2 ** 28), k=N)
        B = random.choices(range(2 ** 28), k=N)
        print('Checking the case with size: {}'.format(N))
        assert simple_solution(N, A, B) == solution(N, A, B)
    print('OK')


def main():
    N = int(input())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))
    print(solution(N, A, B))


if __name__ == '__main__':
    main()
    # check()


Fixed submission:
import numpy as np


def main():
    N = int(input())
    A = np.array(list(map(int, input().split())))
    B = np.array(list(map(int, input().split())))
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = B % (2 * pow_2_k)
        MB.sort()
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        indices_1 = np.searchsorted(MB, pow_2_k - MA, side='left')
        indices_2 = np.searchsorted(MB, 2 * pow_2_k - MA, side='left')
        indices_3 = np.searchsorted(MB, 3 * pow_2_k - MA, side='left')
        cnt += ((N - indices_1) - (N - indices_2) + (N - indices_3)).sum()
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    print(ans)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
def simple_solution(N, A, B):
    ret = 0
    for a in A:
        for b in B:
            ret ^= a + b
    return ret


def solution(N, A, B):
    import bisect
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = [a % (2 * pow_2_k) for a in A]
        MB = [b % (2 * pow_2_k) for b in B]
        MB.sort()
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        for a in MA:
            index_1 = bisect.bisect_left(MB, pow_2_k - a)
            index_2 = bisect.bisect_left(MB, 2 * pow_2_k - a)
            index_3 = bisect.bisect_left(MB, 3 * pow_2_k - a)
            cnt += (N - index_1) - (N - index_2) + (N - index_3)
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    return ans


def check():
    import random
    random.seed(0)
    for N in range(1, 101):
        A = random.choices(range(2 ** 28), k=N)
        B = random.choices(range(2 ** 28), k=N)
        print('Checking the case with size: {}'.format(N))
        assert simple_solution(N, A, B) == solution(N, A, B)
    print('OK')


def main():
    N = int(input())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))
    print(solution(N, A, B))


if __name__ == '__main__':
    main()
    # check()

Fixed submission:
import numpy as np


def main():
    N = int(input())
    A = np.array(list(map(int, input().split())))
    B = np.array(list(map(int, input().split())))
    pow_2_k = 1
    ans = 0
    for k in range(30):
        MA = A % (2 * pow_2_k)
        MB = B % (2 * pow_2_k)
        MB.sort()
        # [2**k, 2 * (2**k)) か [3 * (2**k), 4 * (2**k)) の中に入るとk-bit目が1。
        # この a + b の数をカウントする。
        # → [2**k - a, 2 * (2**k) - a) か [3 * (2**k) - a, 4 * (2**k) - a) の中に入る b の数をカウント。
        cnt = 0
        indices_1 = np.searchsorted(MB, pow_2_k - MA, side='left')
        indices_2 = np.searchsorted(MB, 2 * pow_2_k - MA, side='left')
        indices_3 = np.searchsorted(MB, 3 * pow_2_k - MA, side='left')
        cnt += ((N - indices_1) - (N - indices_2) + (N - indices_3)).sum()
        if cnt % 2 == 1:
            ans += pow_2_k
        pow_2_k *= 2
    print(ans)


if __name__ == '__main__':
    main()