CodeEff/ECCO huggingface dataset:
# Original solution
def main():
    n = int(eval(input()))
    a_lst = [int(eval(input())) for _ in range(n)]

    new_lst = []
    for i in range(n):
        a = a_lst[i]
        if a not in new_lst:
            new_lst.append(a)
        else:
            new_lst.remove(a)

    count = len(new_lst)
    print(count)


if __name__ == '__main__':
    main()

# Optimized solution
def main():
    n = int(eval(input()))
    a_lst = [int(eval(input())) for _ in range(n)]
    a_lst.sort()

    count = 0
    tmp = 0
    number = a_lst[0]

    for i in range(n):

        if a_lst[i] == number:
            tmp += 1

            if i == n - 1:
                if tmp % 2 != 0:
                    count += 1

        else:
            number = a_lst[i]

            if tmp % 2 == 0:
                tmp = 1
                continue
            else:
                count += 1
                tmp = 1

    if n > 1:
        if a_lst[-1] != a_lst[-2]:
            count += 1

    print(count)


if __name__ == '__main__':
    main()
# Original solution
# from pprint import pprint
# import math
# import collections

n = int(eval(input()))
# n, k = map(int, input().split(' '))
# a = list(map(int, input().split(' ')))
a = []
for i in range(n):
    a.append(int(eval(input())))

l = []
for _a in a:
    if _a in l:
        l.remove(_a)
    else:
        l.append(_a)

print((len(l)))

# Optimized solution
# from pprint import pprint
# import math
# import collections

n = int(eval(input()))
# n, k = map(int, input().split(' '))
# a = list(map(int, input().split(' ')))
a = []
for i in range(n):
    a.append(int(eval(input())))

l = {}
for _a in a:
    if _a in l:
        l.pop(_a)
    else:
        l.update(
            {_a: True}
        )

print((len(l)))
# Original solution
N=int(eval(input()))
sisterN=[]
SISTERn=[]
SISterN=[]
for n in range(N):
    _=int(eval(input()))
    if _<50000:
        _s= _
        if sisterN.count(_s)==1:
            sisterN.remove(_s)
        else:
            sisterN.append(_s)
    elif 50001<_<80000:
        _m= _
        if SISterN.count(_m)==1:
            SISterN.remove(_m)
        else:
            SISterN.append(_m)
    elif 80001<_:
        _b= _
        if SISTERn.count(_b)==1:
            SISTERn.remove(_b)
        else:
            SISTERn.append(_b)

print((len(sisterN)+len(SISTERn)+len(SISterN)))



# Optimized solution
N=int(eval(input()))
S=set()

for n in range(N):
    _=int(eval(input()))
    if _ in S:
        S.remove(_)
    else:
        S.add(_)

print((len(S)))
# Original solution
N = int(eval(input()))
A = []
for i in range(N):
    c = int(eval(input()))
    if c not in A:
        A.append(c)
    else:
        A.remove(c)

print((len(A)))

# Optimized solution
N = int(eval(input()))
A = []
for i in range(N):
    A.append(int(eval(input())))
cnt = 1
ans = 0
A.sort()
for i in range(N-1):
    if A[i] == A[i+1]:
        cnt += 1
    else:
        if cnt%2 == 1:
            ans += 1
        cnt = 1
if cnt%2 == 1:
    ans += 1
print(ans)
# Original solution
n = int(eval(input()))
al = []
for _ in range(n):
    a = int(eval(input()))
    if a in al:
        al.remove(a)
    else:
        al.append(a)
    
print((len(al)))

# Optimized solution
n = int(eval(input()))
al = []
for _ in range(n):
    a = int(eval(input()))
    al.append(a)

al = sorted(al)
ans = 0

before = 0
for a in al:
    if before == a:
        ans -= 1
        before = 0
    else:
        ans += 1
        before = a
    
print(ans)
# Original solution
import collections
import sys
input = sys.stdin.readline

n = int(eval(input()))
a = [0]*n
ans = 0
for i in range(n):
    a[i] = int(eval(input()))
count_a = collections.Counter(a).most_common()
for i in range(len(count_a)):
    if count_a[i][1]%2 != 0:
        ans += 1
print(ans)

# Optimized solution
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

from collections import Counter

n = int(readline())
a = [int(readline()) for _ in range(n)]
ans = 0
for v in list(Counter(a).values()):
    ans += 1 if v % 2 == 1 else 0
print(ans)
# Original solution
N=int(eval(input()))
A=[None]*N

for i in range(N):
    A[i]=int(eval(input()))

B=[None]
Ans=0
for i in A:
    if i in B:
        continue
    else:
        if A.count(i)%2==1:
            Ans+=1
            B+=[i]



print(Ans)


# Optimized solution
N=int(eval(input()))
A=[None]*N

for i in range(N):
    A[i]=int(eval(input()))

Ans=0
A.sort()
A+=[-1]
j=1
for i in range(1,N+1):
    if A[i]==A[i-1]:
        j+=1
    else:
        if j%2==1:
            Ans+=1
        j=1

print(Ans)
# Original solution
import sys
from io import StringIO
import unittest

def yn(b):
    print(("Yes" if b==1 else "No"))
    return

def resolve():
    readline=sys.stdin.readline
    n=int(readline())
    aa=[]
    for _ in range(n):
        a = readline().strip()
        if a in aa:
            aa.remove(a)
        else:
            aa.append(a)
    print((len(aa)))
    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

# Optimized solution
import sys
from io import StringIO
import unittest

def yn(b):
    print(("Yes" if b==1 else "No"))
    return

def resolve():
    readline=sys.stdin.readline
    n=int(readline())
    d={}
    for _ in range(n):
        a = readline().strip()
        if a in d:
            d[a]+=1
        else:
            d[a]=1
    cnt=0
    for key in d:
        if d[key]%2==1:
            cnt+=1
    print(cnt)
    return

if 'doTest' not in globals():
    resolve()
    sys.exit()
# Original solution
n = int(eval(input()))
ans = []

for i in range(n):
    a = int(eval(input()))
    if a in ans:
        ans.remove(a)
    else:
        ans.append(a)

print((len(ans)))


# Optimized solution
n = int(eval(input()))
ans = set()

for i in range(n):
    a = int(eval(input()))
    if a in ans:
        ans.remove(a)
    else:
        ans.add(a)

print((len(ans)))
# Original solution
n = int(eval(input()))
apple = []
for _ in range(n):
    a = str(eval(input()))
    if a not in apple:
        apple.append(a)
    else:
        apple.remove(a)
print((len(apple)))

# Optimized solution
n = int(eval(input()))
apple = []
for _ in range(n):
    apple.append(int(eval(input())))
apple = sorted(apple)
apple.append(0)
count = 0
ans = 1
for i in range(n):
    if apple[i] == apple[i + 1]:
        ans += 1
    else:
        if ans%2 == 0:
            ans = 1
        else:
            count += 1
print(count)
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
As = set(A)

ans = 0
for a in As:
    if A.count(a) % 2 == 0:
        pass
    else:
        ans += 1

print(ans)

# Optimized solution
'''
全量のリストを用いると検索対象が大きくなってしまうため、ディクショナリで都度追加/削除する
'''

N = int(eval(input()))

A = {}

for _ in range(N):
    tmp = int(eval(input()))
    if tmp in A:
        del A[tmp]
    else:
        A[tmp] = 1

print((len(A)))
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
q = []
for i in range(N):
  if A[i] in q:
    q.remove(A[i])
  else:
    q.append(A[i])
print((len(q)))


# Optimized solution
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
A.sort()
c = 1
ans = 0
for i in range(N-1):
  if A[i] == A[i+1]:
    c += 1
  else:
    if c % 2 == 1:
      ans += 1
    c = 1
if c % 2 == 1:
  ans += 1
print(ans)
# Original solution
N=int(eval(input()))
A=[int(eval(input())) for _ in range(N)]
A=list(map(A.count, set(A)))
ans=0
for a in A:
    if a%2:ans+=1
print(ans)

# Optimized solution
N=int(eval(input()))
A=[int(eval(input())) for _ in range(N)]
d={}
for a in A:d[a]=0
for a in A:d[a]+=1
cnt=0
for i in d:
    if d[i]%2:cnt+=1
print(cnt)
# Original solution
n = int(eval(input()))
a = []
for i in range(n):
    tmp = int(eval(input()))
    if tmp in a:
        a.remove(tmp)
    else:
        a.append(tmp)

print((len(a)))

# Optimized solution
n = int(eval(input()))
a = {}
cnt = 0
for i in range(n):
    tmp = int(eval(input()))
    if tmp not in a:
        a[tmp] = 1
    else:
        a[tmp] += 1

for v in list(a.values()):
    if v % 2 != 0:
        cnt += 1

print(cnt)
# Original solution
# encoding: utf-8
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]

A.sort()

tag = -1
cnt = 0
ans = 0
for Ai in A:
    if Ai > tag:
        tag = Ai
        ans += cnt % 2
        cnt = 0
    cnt += 1
else:
    ans += cnt % 2
        
print(ans)

# Optimized solution
N = int(eval(input()))
A = [eval(input()) for _ in range(N)]

cnt = {}
for Ai in A:
    key = str(Ai)
    cnt[key] = cnt.setdefault(key, 0) + 1

ans = sum([cnt[key] % 2 for key in list(cnt.keys())])
print(ans)
# Original solution
_,a,*s=open(0)
a={a}
for i in s:a^={i}
print((len(a)))

# Optimized solution
_,*s=open(0)
a=set()
for i in s:a^={i}
print((len(a)))
# Original solution
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
num = []
for i in range(n-1):
    for j in range(i+1, n):
        if a[i] == a[j]:
            num.append(a[i])
print((n - 2 * len(num)))
            

# Optimized solution
n = int(eval(input()))
num = set()
ans = 0

for i in range(n):
    a = int(eval(input()))
    if a in num:
        num.remove(a)
        ans -= 1
    else:
        num.add(a)
        ans += 1
print(ans)
# Original solution
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
ans = 0
for i in A:
    if A.count(i) % 2 != 0:
        ans += 1
print(ans)

# Optimized solution
n = int(eval(input()))
s = set()
for i in range(n):
    k = int(eval(input()))
    if k in s:
        s.remove(k)
    else:
        s.add(k)
print((len(s)))
# Original solution
n = int(eval(input()))

d = set([])
for _ in range(n):
    d = d ^ set([int(eval(input()))])
    
print((len(d)))

# Optimized solution
n = int(eval(input()))

d = set()
for _ in range(n):
    d ^= {eval(input())}
    
print((len(d)))
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
print((sum([1 for a in A if A.count(a)%2==1])))

# Optimized solution
s = set()

for i in range(int(eval(input()))):
  s^={eval(input())}

print((len(s)))
# Original solution
N = int(eval(input()))
A = []
for i in range(N):
    n = int(eval(input()))
    if not (n in A):
        A.append(n)
    else:
        A.remove(n)
print((len(A)))

# Optimized solution
N = int(eval(input()))
A = set()
for i in range(N):
    n = int(eval(input()))
    if not (n in A):
        A.add(n)
    else:
        A.remove(n)
print((len(A)))
# Original solution
Figures = []
N = int(eval(input()))
for _ in range(N):
  x = int(eval(input()))
  if x in Figures:
    Figures.remove(x)
  else:
    Figures.append(x)
print((len(Figures)))

# Optimized solution
dic = {}
N = int(eval(input()))
for _ in range(N):
  x = int(eval(input()))
  if x in dic:
    dic[x] += 1
  else:
    dic[x] = 1
counter = 0
for i in list(dic.keys()):
  if dic[i] %2 == 1:
    counter +=1
print(counter)
# Original solution
n = int(eval(input()))
 
l = []
for i in range(n) :
    a = int(eval(input()))
    l.append(a)

l.sort(reverse=False)
count_sum = 0   
for j in set(l):
    count = 0
    for  k in  range(l.index(j),len(l)):
        if l[k] == j :
            count += 1
        else :
            break
    count_sum += count%2

print(count_sum)

# Optimized solution
n = int(eval(input()))

answer = {}
for i in range(n):
  ai = int(eval(input()))
  if answer.get(ai):
    answer.pop(ai)
  else:
    answer[ai] = 1
    
print((len(answer)))
# Original solution
n = int(eval(input()))

num_list = []
for i in range(n):
    a = int(eval(input()))
    if a in num_list:
        num_list.remove(a)
    else:
        num_list.append(a)

print((len(num_list)))

# Optimized solution
n = int(eval(input()))

num_list = []
for i in range(n):
    a = int(eval(input()))
    num_list.append(a)

num_list.sort()
num_list2 = []
i = 0
while i < n:
    if i == n-1:
        num_list2.append(num_list[i])
        break
    elif num_list[i] == num_list[i+1]:
        i += 2
    else:
        num_list2.append(num_list[i])
        i += 1


print((len(num_list2)))
# Original solution
n = int(eval(input()))
s = 0
lst = []
for _ in range(n):
  tmp = int(eval(input()))
  if tmp in lst:
    s -= 1
    lst.remove(tmp)
  else:
    s += 1
    lst.append(tmp)
print(s)

# Optimized solution
n = int(eval(input()))
dic = {}
for _ in range(n):
  tmp = int(eval(input()))
  if tmp in dic and dic[tmp] == 1:
    dic[tmp] = 0
  else:
    dic[tmp] = 1
print((sum(dic.values())))
# Original solution
N=int(eval(input()))
history=[]
for i in range(N):
  history.append(int(eval(input())))
history=sorted(history)
print((sum([history.count(n)%2 for n in list(set(history))])))

# Optimized solution
N=int(eval(input()))
history=[]
for i in range(N):
  history.append(int(eval(input())))
history=sorted(history)
nums=[]
for i in range(N):
  if i==0:
    nums.append(1)
  else:
    if history[i]==history[i-1]:
      nums[-1]+=1
    else:
      nums.append(1)
print((sum([n%2 for n in nums])))
# Original solution
n = int(eval(input()))
card = []
for i in range(n):
    num = int(eval(input()))
    if num in card:
        card.remove(num)
    else:
        card.append(num)
print((len(card)))

# Optimized solution
n = int(eval(input()))
card = set()

for i in range(n):
    num = int(eval(input()))
    if num in card:
        card.remove(num)
    else:
        card.add(num)
print((len(card)))
# Original solution
def ai():return input()#s
def a():return int(input())#a,n or k
def ma():return map(int, input().split())#a,b,c,d or n,k
def ms():return map(str, input().split())#,a,b,c,d
def lma():return list(map(int, input().split()))#x or y
def lms():return list(map(str, input().split()))#x or y
k= []
l = []
f = 0
def say(i):return print("Yes" if i == 0 else "No")
def Say(i):return print("YES" if i == 0 else "NO")

a = int(input())
c =[0]*a
for i in range(a):
    t = int(input())
    k.append(t)
p = set(k)
for i in p:
    f+=k.count(i)%2
print(f)


# Optimized solution
def ai():return input()#s
def a():return int(input())#a,n or k
def ma():return map(int, input().split())#a,b,c,d or n,k
def ms():return map(str, input().split())#,a,b,c,d
def lma():return list(map(int, input().split()))#x or y
def lms():return list(map(str, input().split()))#x or y
k= []
l = []
f = 0
def say(i):return print("Yes" if i == 0 else "No")
def Say(i):return print("YES" if i == 0 else "NO")

a = int(input())
c=set()
for i in range(a):
    t = int(input())
    if t in c:
        c.remove(t)
    else:
        c.add(t)
print(len(c))
# Original solution
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]

b = set()
lenB = 0
for a in A:
    b.add(a)
    lenB += 1
    if len(b) != lenB:
        b.remove(a)
        lenB -= 2
print((len(b)))


# Optimized solution
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
 
B = set()
lenB = 0
for a in A:
    if a in B:
        B.remove(a)
        lenB -= 1
    else:
        B.add(a)
        lenB += 1
print(lenB)
# Original solution
from collections import Counter
from sys import stdin

lines = stdin.readlines
N, *A = [int(line) for line in lines()]

An = Counter(A)


def main():
    print((sum([1 for k, v in list(An.items()) if v % 2])))
    return


main()


# Optimized solution
from collections import Counter
from sys import stdin

lines = stdin.readlines

N, *A = list(map(int, lines()))
An = Counter(A)


def main():
    print((sum([1 for v in list(An.values()) if v % 2])))
    return


main()
# Original solution
n = int(eval(input()))

f = {}
for i in range(n):
    a = int(eval(input()))
    if not f.get(a):
        f[a] = True
    else:
        f[a] = None

print((sum(1 for i in f if f[i])))


# Optimized solution
field = {}
a = [int(eval(input())) for x in range(int(eval(input())))]


for i in a:
  tmp = field.get(i)
  if not tmp:
    field[i] = True
  else:
    field[i] = False
print((sum(field.values())))
# Original solution
n=int(eval(input()))
buff=[]
for i in range(n):
    a=int(eval(input()))
    if a in buff:
        buff.remove(a)
    else:
        buff.append(a)

print((len(buff)))

# Optimized solution
n=int(eval(input()))
buff=[]
ans=1
for i in range(n):
    buff.append(eval(input()))

a=sorted(buff)

for i in range(1,n):
    if a[i] == a[i-1]:
        a[i-1]= -1
        a[i]= -1
        if ans>0:
            ans -= 1
    else:
        ans += 1

print(ans)
# Original solution
n=int(eval(input()))
buff=[]
ans=1
for i in range(n):
    buff.append(eval(input()))

a=sorted(buff)

for i in range(1,n):
    if a[i] == a[i-1]:
        a[i-1]= -1
        a[i]= -1
        if ans>0:
            ans -= 1
    else:
        ans += 1

print(ans)


# Optimized solution
n=int(eval(input()))
buff=set()
for i in range(n):
    a=int(eval(input()))
    if a in buff:
        buff.remove(a)
    else:
        buff.add(a)

print((len(buff)))
# Original solution
N=int(eval(input()))
s=set()
for i in range(N):s^={eval(input())}
print((len(s)))

# Optimized solution
n = int(eval(input()))
a = set()
for _ in range(n):
    a ^= {eval(input())}
print((len(a)))
# Original solution
n = int(eval(input()))

a = []
for _ in range(n):
    p = int(eval(input()))
    if p not in a:
        a.append(p)
    else:
        a.remove(p)

print((len(a)))


# Optimized solution
n = int(eval(input()))

a = [int(eval(input())) for _ in range(n)]

a = sorted(a)

ans = n
flag = 0
for i in range(1, n):
    if a[i] != a[i-1] or flag == 1:
        flag = 0
    else:
        flag = 1
        ans -= 2

print(ans)
# Original solution
from collections import defaultdict

N=int(eval(input()))
An=defaultdict(int)
for _ in range(N):
    An[int(eval(input()))]+=1

print((len(list([v for v in list(An.values()) if v%2==1]))))


# Optimized solution
from collections import Counter

N,*An=list(map(int, open(0).read().split()))

count=Counter(An)
print((len(list([v for v in list(count.values()) if v%2==1]))))
# Original solution
n = int(eval(input()))
a = [input().split() for i in range(n)]

count = 0
 
for i in a:
    ii = a.count(i)
    if ii%2 ==1:
        count += 1

print(count)

# Optimized solution
n = int(eval(input()))
a = [eval(input()) for i in range(n)]

count = 0
dic = {}

for i in a:
    if i in dic:
        dic[i] += 1
    else:
        dic[i] = 1

for i in list(dic.values()):
    if i%2 == 1:
        count += 1

print(count)
# Original solution
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
b = set(a)

ans = 0
for x in b:
    if a.count(x) % 2 == 1:
       ans += 1

print(ans)

# Optimized solution
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
b = set(a)
d = {i: 0 for i in b}

for i in a:
    d[i] += 1

ans = 0
for v in list(d.values()):
    if v%2 == 1:
        ans += 1
print(ans)
# Original solution
from sys import stdin
import sys
import math

N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]

h = {}

for i in A:
    h[i] = 0

for j in A:
    h[j] += 1


count = 0
for key in list(h.keys()):
    if h[key] % 2 == 1:
        count += 1

print(count)


# Optimized solution
from sys import stdin
import sys
import math

N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]

h = {}

for i in A:
    h[i] = 0

for j in A:
    h[j] += 1


count = 0
for val in list(h.values()):
    if val % 2 == 1:
        count += 1

print(count)
# Original solution
from collections import Counter
n = int(eval(input()))
a = Counter([eval(input()) for i in range(n)])
c=0
for i in a:
    if a[i]%2:
        c += 1
print(c)

# Optimized solution
from collections import Counter
n = int(eval(input()))
l = [int(eval(input())) for _ in range(n)]
a= list(Counter(l).values())
print((sum(1 for i in a if i%2)))
# Original solution
from collections import Counter
n = int(eval(input()))
l = [int(eval(input())) for _ in range(n)]
a = list(Counter(l).values())
print((sum(i%2 for i in a)))

# Optimized solution
from collections import Counter
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
l = list(Counter(a).values())
print((sum(i%2 for i in l)))
# Original solution
N = int(eval(input()))

A = []

for _ in range(N):
    a = int(eval(input()))
    if a in A:
        A.remove(a)
    else:
        A.append(a)

print((len(A)))

# Optimized solution
N = int(eval(input()))

A = set()

for _ in range(N):
    a = int(eval(input()))
    if a in A:
        A.remove(a)
    else:
        A.add(a)

print((len(A)))
# Original solution
from collections import Counter

N = int(eval(input()))
A = []

for _ in range(N):
    A.append(int(eval(input())))

ans = 0
counter = Counter(A)
for _, cnt in counter.most_common():
    if cnt % 2 == 1:
        ans += 1
        
print(ans)

# Optimized solution
from collections import Counter

def main():
    N = int(eval(input()))
    A = []

    for _ in range(N):
        A.append(int(eval(input())))

    ans = 0
    counter = Counter(A)
    for _, cnt in counter.most_common():
        if cnt % 2 == 1:
            ans += 1

    print(ans)
    
main()
# Original solution
n=int(eval(input()))
list=[]
ans=0
for i in range(n):
    a=int(eval(input()))
    list.append(a)
for i in range(n):
    if list.count(list[i])%2!=0:
        ans+=1
print(ans)

# Optimized solution
n=int(eval(input()))
list=[]
ans=0
sa=1
sas=0
for i in range(n):
    a=int(eval(input()))
    list.append(a)
list=sorted(list)
list.append(10000000000)
for i in range(n+1):
    if i!=0:
        if list[i]==list[i-1]:
            sa+=1
        else:
            sas=sa
            sa=1
            if sas%2!=0:
                ans+=1
print(ans)
# Original solution
n = int(eval(input()))
s = set()

for i in range(n):
    s = s ^ {eval(input())}

print((len(s)))

# Optimized solution
n = int(eval(input()))
s = set()

for i in range(n):
    s ^= {eval(input())}

print((len(s)))
# Original solution
n = int(eval(input()))
s = set()

for i in range(n):
    s = {eval(input())} ^ s

print((len(s)))


# Optimized solution
n = int(eval(input()))
s = set()

for i in range(n):
    s ^= {int(eval(input()))}

print((len(s)))
# Original solution
n = int(eval(input()))
a = []
for i in range(n):
	s = int(eval(input()))
	if s in a:
		a.remove(s)
	else:
		a.append(s)
print((len(a)))

# Optimized solution
n = int(eval(input()))
a = []
for i in range(n):
	s = int(eval(input()))
	a.append(s)
a.sort()
a.append(0)
length = 0
i = 0
while i < n:
	counter = 1
	count = 0
	for k in range(i+1,n+1):
		if a[i] != a[k] and counter%2 == 1:
			length += 1
			i = i+count+1
			break
		elif a[i] != a[k] and counter%2 == 0:
			i = i+count+1
			break
		elif a[i] == a[k]:
			counter += 1
			count += 1
print(length)
# Original solution
n = int(eval(input()))
l = []
for i in range(n):
    tmp = int(eval(input()))
    l.remove(tmp) if tmp in l else l.append(tmp)
print((len(l)))


# Optimized solution
n = int(eval(input()))
l = set()
for i in range(n):
    tmp = int(eval(input()))
    l.remove(tmp) if tmp in l else l.add(tmp)
print((len(l)))
# Original solution
N = int(eval(input()))
memo = []
for i in range(N):
  A = int(eval(input()))
  if(A in memo):
    memo.remove(A)
  else:
    memo.append(A)
print((len(memo)))

# Optimized solution
N = int(eval(input()))
memo = {}
for i in range(N):
  A = int(eval(input()))
  if(A in memo):
    memo[A] += 1
  else:
    memo[A] = 1
cnt = 0
for k, v in list(memo.items()):
  cnt += v%2
print(cnt)
# Original solution
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
B=list(set(A))
count=0
for i in range(len(B)):
  if A.count(B[i])%2!=0:
    count+=1
print(count)

# Optimized solution
n=int(eval(input()))
a=[int(eval(input())) for i in range(n)]
d={}
for i in range(n):
  if a[i] in d:
    d[a[i]]+=1
  else:
    d[a[i]]=1
cnt=0
d=list(d.items())
for i in range(len(d)):
  if d[i][1]%2==1:
    cnt+=1
print(cnt)
# Original solution
n=int(eval(input()))
a=[int(eval(input())) for i in range(n)]
b=[]
count=0

for i in a: 
    if i not in b:
        b.append(i)

for i in b:
    if a.count(i)%2==1:
        count=count+1

print(count)


# Optimized solution
n=int(eval(input()))
a=[int(eval(input())) for i in range(n)]
b=[]

m=0
count=[0 for i in range(n)]
count[m]=1

ans_count=0
a.sort()

for i in range(n-1):
    if a[m]==a[i+1]:
        count[m]=count[m]+1
    else:
        m=i+1
        count[m]=1

for i in range(n):
     ans_count=ans_count+count[i]%2

print(ans_count)