CodeEff/ECCO huggingface dataset:
# Original solution
n = int(eval(input()))

num = []
cnt = 0

for i in range(n):
    a = int(eval(input()))
    if a in num:
        num.pop(num.index(a))
        cnt -= 1
    else:
        num.append(a)
        cnt += 1

print(cnt)


# Optimized solution
n = int(eval(input()))
A = []

for i in range(n):
    a = int(eval(input()))
    A.append(a)

A.sort()

odd = 0
prev = A[0]
cnt = 1

for i in range(1,n):
    if A[i] != prev:
        if cnt % 2 == 1:
            odd += 1
        cnt = 1
        prev = A[i]
    else:
        cnt += 1

if cnt % 2 == 1:
    odd += 1

print(odd)
# Original solution
ans = 0
n = int(eval(input()))
l = [eval(input()) for _ in range(n)]
s = set(l)
for i in s:
  if l.count(i)%2 != 0:
    ans += 1
print(ans)

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

# Optimized solution
N = int(eval(input()))
L = [int(eval(input())) for i in range(N)]
L.sort()
res = 0
i = 0
while i < len(L)-1:
    if L[i] == L[i+1]:
        res += 2
        i += 1
    i += 1
    
print((len(L)-res))
# Original solution

def solve():
  n = int(eval(input()))
  l = []
  for i in range(n):
    a = int(eval(input()))
    l.append(a)
  
  bit = 0
  for j in l:
    bit ^= (1 << j)

  ans = countSetBits(bit)
  print(ans)

def countSetBits(n):
  count = 0
  while(n):
    count += n & 1
    n >>= 1
  return count

if __name__ == "__main__":
  solve()

# Optimized solution
n = int(eval(input()))
di = {}

for x in range(n):
  i = int(eval(input()))
  if (i in list(di.keys())):
    di.pop(i)
  else:
    di[i] = i
print((len(di)))
# Original solution
N=int(eval(input()))
A=[]
for i in range(N):
    a=int(eval(input()))
    if a not in A:
        A.append(a)
    else:
        A.remove(a)
print((len(A)))

# Optimized solution
N=int(eval(input()))
A=set()
for i in range(N):
    a=int(eval(input()))
    if a not in A:
        A.add(a)
    else:
        A.remove(a)
print((len(A)))
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
A_s = list(set(A))
cnt = 0
for i in A_s:
    if A.count(i) % 2 == 1:
        cnt += 1
print(cnt)

# Optimized solution
n = int(eval(input()))
paper = {}
for i in range(n):
    number = eval(input())
    if number in paper:
        del paper[number]
    else:
        paper[number] = 1
print((len(paper)))
# Original solution
n = int(eval(input()))
a = []
ans = 0
for i in range(n):
    a.append(int(eval(input())))
set_a = set(a)
for i in set_a:
    ans += a.count(i) % 2
print(ans)

# Optimized solution
n = int(eval(input()))
evole = set()
ans = 0
for i in range(n):
    var = int(eval(input()))
    if var in evole:
        evole.remove(var)
        ans -= 1
    else:
        evole.add(var)
        ans += 1
print(ans)
# Original solution
n=int(eval(input()))
A=[int(eval(input())) for _ in range(n)]
B=set(A)
ans=0
for i in B:
    c=A.count(i)
    ans+=c%2
print(ans)

# Optimized solution
n=int(eval(input()))
A=[int(eval(input())) for _ in range(n)]
B={}
for i in A:
    if i in B:
        B[i]=(1+B[i])%2
    else:
        B[i]=1
print((sum(B.values())))
# Original solution
from collections import Counter

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

c = Counter(A)
ans = 0
for k, v in list(c.items()):
    ans += v % 2
print(ans)

# Optimized solution
import sys
from collections import Counter

input = sys.stdin.readline

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

ans = len([v for v in list(Counter(A).values()) if v % 2 == 1])
print(ans)
# Original solution
N=int(eval(input()))
s=set()
for i in range(N):
  a=int(eval(input()))
  if a in s:
    s.remove(a)
  else:
    s.add(a)
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()))

kami = []

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

print((len(kami)))


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

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

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


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

paper = []
numbers = [int(eval(input())) for _ in range(N)]

for n in numbers:
    if n in paper:
        paper.remove(n)
    else:
        paper.append(n)

print((len(paper)))

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

paper = []
numbers = sorted([int(eval(input())) for _ in range(N)])

# for n in numbers:
for i in range(N - 1):
    if numbers[i] == numbers[i + 1]:
        numbers[i] = -1
        numbers[i + 1] = -1
    if numbers[i] != -1:
        paper.append(numbers[i])

if numbers[N - 1] != -1:
    paper.append(numbers[N - 1])
print((len(paper)))
# Original solution
import sys
imput=sys.stdin.readline
n=int(eval(input()))
c=[]
for i in range(n):
    a=int(eval(input()))
    if a not in c:
        c.append(a)
    else:
        c.remove(a)
print((len(c)))

# Optimized solution
n=int(eval(input()))
a=[int(eval(input())) for i in range(n)]
a.append(1000000001)
a.append(0)
a.sort()
c=0
ans=0
s=0
#print(a)
for i in range(1,n+2):
    if a[i]==c:
        s+=1
    else:
        ans+=(s%2)
        c=a[i]
        s=1
    #print(s)
print(ans)
# Original solution
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
dic = {}
for i in range(n):
    if a[i] in dic:
        del dic[a[i]]
    else:
        dic[a[i]] = None
print((len(dic)))

# Optimized solution
n = int(eval(input()))
dic = {}
for i in range(n):
    a = eval(input())
    if a in dic:
        del dic[a]
    else:
        dic[a] = None
print((len(dic)))
# Original solution
import sys
n,*A = sys.stdin
B = set()
for a in A:
    if int(a) in B:
        B.remove(int(a))
    else:
        B.add(int(a))
print((len(B)))

# Optimized solution
import sys
n,*A = list(map(int,sys.stdin))
B = set()
for a in A:
    if a in B:
        B.remove(a)
    else:
        B.add(a)
print((len(B)))
# Original solution
# coding;utf-8

n=int(eval(input()))
ans_list=[]
for i in range(0, n):
    a=eval(input())
    if a in ans_list:
        ans_list.remove(a)
    else:
        ans_list.append(a)
print((len(ans_list)))


# Optimized solution
# coding;utf-8

n=int(eval(input()))
ans_dict={}
for i in range(0, n):
    a=eval(input())
    if not a in ans_dict:
        ans_dict[a]=1
    else:
        ans_dict[a]+=1
sum=0
for thing in ans_dict:
    if ans_dict[thing]%2:
        sum+=1
print(sum)
# Original solution
#feel like this is to easy

def read_input():
  n = int(eval(input()))
  a = []
  for i in range(n):
    a.append(int(eval(input())))
  return n,a

def TLE():
  n,a = read_input()
  sheet = []
  for item in a:
    if item not in sheet:
      sheet.append(item)
    else:
      sheet.pop(sheet.index(item))
  print((len(sheet)))
  
def main():
  n,a = read_input()
  items = list(set(a))
  count = 0
  for item in items:
    if a.count(item)%2 != 0:
      count += 1
  print(count)

if __name__ == '__main__':
  main()

# Optimized solution
#feel like this is to easy

def read_input():
  n = int(eval(input()))
  a = []
  for i in range(n):
    a.append(int(eval(input())))
  return n,a

def TLE():
  n,a = read_input()
  sheet = []
  for item in a:
    if item not in sheet:
      sheet.append(item)
    else:
      sheet.pop(sheet.index(item))
  print((len(sheet)))
  
def TLE2():
  n,a = read_input()
  items = list(set(a))
  count = 0
  for item in items:
    if a.count(item)%2 != 0:
      count += 1
  print(count)

def main():
  n,a = read_input()
  a.sort()
  items = list(set(a)).sort()
  t = 1
  count = 0
  for i in range(len(a)):
    if i+1 == len(a):
      count += t%2
      break
    if a[i] == a[i+1]:
      t += 1
    else:
      count += t%2
      t = 1
  print(count)

if __name__ == '__main__':
  main()
# Original solution
n = int(eval(input()))
s = []
for i in range(n):
    a = int(eval(input()))
    if a in s:
        del s[s.index(a)]
    else:
        s.append(a)

print((len(s)))


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

a.sort()
a.append(0)
erased = 0
ans = 0
for i in range(1,n+1):
    if a[i-1] == a[i]:
        erased = (erased+1)%2
    else:
        if erased == 0:
            ans += 1
        erased = 0
print(ans)
# Original solution
n=int(eval(input()))
a=[]
for i in range(n):
    b=int(eval(input()))
    if b in a:
        a.remove(b)
    else:
        a.append(b)
print((len(a)))


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

for i in range(n):
    a = int(eval(input()))
    tmp = list(set(tmp))
    if not (a in tmp):
        tmp.append(a)
    else:
        tmp.remove(a)

print((len(tmp)))


# Optimized solution
n=int(eval(input()))
a=set()
for i in range(n):
    b=int(eval(input()))
    if b in a:
        a.remove(b)
    else:
        a.add(b)
print((len(a)))
# Original solution
N = int(eval(input()))
list = []
cnt = 0
for i in range(N):
  A = int(eval(input()))
  list.append(A)
  if list.count(A) > 1:
    cnt -= 1
  else:
    cnt += 1
print(cnt)

# Optimized solution
N = int(eval(input()))
set = set()
for i in range(N):
  A = int(eval(input()))
  if A in set:
    set.remove(A)
  else:
    set.add(A)
print((len(set)))
# Original solution
import collections

N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
ans = 0
num = collections.Counter(A).most_common()

for a, b in num:
    if b % 2 != 0:
        ans += 1

print(ans)

# Optimized solution
import collections
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
ans = 0
dict = collections.Counter(A)

for a, b in list(dict.items()):
    if b % 2 != 0:
        ans += 1
print(ans)
# Original solution
n = int(eval(input()))
li = []
for i in range(n):
    a = eval(input())
    if a in li:
        li.remove(a)
    else:
        li.append(a)

print((len(li)))
        

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

c = [a.count(x) for x in set(a)]
print((len([x for x in c if x % 2 == 1])))


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

y = a[0]
c = 1
ans = 0
for i in range(1, n):
   if (a[i] == y):
      c += 1
   else:
      if (c % 2 == 1):
         ans += 1
      y = a[i]
      c = 1

if (c % 2 == 1):
   ans += 1

print(ans)
# Original solution
n = int(eval(input()))
A = [eval(input()) for _ in range(n)]
AS = set(A)
ASd = set(A)
for i in ASd:
    if A.count(i) % 2 == 0:
        AS.remove(i)
print((len(AS)))

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

print((len(l)))

# Optimized solution
N = int(eval(input()))
alist = sorted([int(eval(input())) for x in range(N)])

tmpNum = alist[0]
cnt = 1
ans = 0
for i in range(1, N):
	num = alist[i]
	if tmpNum == num:
		cnt = cnt + 1
		if i == N-1 and cnt % 2 != 0:
			ans = ans + 1
	else:
		if cnt % 2 != 0:
			ans = ans + 1
		tmpNum = num
		cnt = 1
		if i == N-1:
			ans = ans + 1

if len(alist) == 1:
	ans = ans + 1


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

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

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

print((len(A)))


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

word = []
for i in range(N):
    a = int(eval(input()))
    if a in word:
        word.remove(a)
    else:
        word.append(a)
        
print((len(word)))

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

word = set()
for i in range(N):
    a = int(eval(input()))
    if a in word:
        word.remove(a)
    else:
        word.add(a)
        
print((len(word)))
# Original solution
N=int(eval(input()))
s=set()
for i in range(N):s^={eval(input())}
print((len(s)))

# Optimized solution
s=set()
for i in range(int(eval(input()))):s^={eval(input())}
print((len(s)))
# Original solution
n = int(eval(input()))
l = []
count = 0
for i in range(n):
    a = int(eval(input()))
    if a in l:
        l.remove(a)
        count -= 1
    else:
        l.append(a)
        count += 1
print(count)

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

l = sorted(a)
same = 1
count = 0
for i in range(1, n):
    if l[i] == l[i - 1]:
        same += 1
        continue
    if same % 2 == 1:
        count += 1
    same = 1
if same % 2 == 1:
    count += 1
print(count)
# Original solution
N = int(eval(input()))
list = []
for i in range(N):
    i = int(eval(input()))
    if i not in list:
        list.append(i)
    elif i in list:
        list.remove(i)
print((len(list)))

# Optimized solution
N = int(eval(input()))
list = set()
for i in range(N):
    i = int(eval(input()))
    if i not in list:
        list.add(i)
    elif i in list:
        list.remove(i)
print((len(list)))
# Original solution
N = int(eval(input()))

ans = 0
L = []
for i in range(N):
    L.append(int(eval(input())))

l = set(L)

for j in l:
    if L.count(j)%2 == 1:
        ans += 1
print(ans)

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

ans = 0
L = []
ans_L = {}

for i in range(N):
    L.append(int(eval(input())))

for j in L:
    if not j in list(ans_L.keys()):
        ans_L[j] = 0
    
    if ans_L[j]==0:
        ans_L[j] += 1
    elif ans_L[j]== 1:
        ans_L[j] -= 1

print((sum(ans_L.values())))
# Original solution
from collections import deque
N = int(eval(input()))
ans = deque([])
for _ in range(N):
    a = int(eval(input()))
    if a not in ans:
        ans.append(a)
    else:
        ans.remove(a)
print((len(ans)))

# Optimized solution
from collections import Counter
N = int(eval(input()))
ans = Counter([int(eval(input())) for _ in range(N)])
cnt = 0
for c in list(ans.values()):
    if c%2 == 1:
        cnt += 1
print(cnt)
# Original solution
from collections import Counter
N=int(eval(input()))
A=Counter([int(eval(input())) for i in range(N)])
ans=0
for count in list(A.values()):
    if count%2:
        ans+=1
print(ans)

# Optimized solution
from collections import Counter
N=int(eval(input()))
A=Counter([int(eval(input())) for i in range(N)])
print((sum(1 if count%2 else 0 for count in list(A.values()))))
# Original solution
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().strip()

n = ni()
a = [ni() for _ in range(n)]

a.sort()
count = 0
ans = 0
for i in a:
    count = a.count(i)
    if count % 2 != 0:
        ans += 1
print(ans)


# Optimized solution
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().strip()

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

A.sort()

result = 0
cur = 0
while cur < N:
    a = A[cur]
    count = 0
    while cur < N and A[cur] == a:
        cur += 1
        count += 1
    result += count % 2

print(result)

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

paper = set()
for a in A:
    paper ^= {a}

print((len(paper)))
# Original solution
from collections import deque
n=int(eval(input()))
numList=deque([])
for i in range(n):
    a=eval(input())
    if a in numList:
        numList.remove(a)
    else:
        numList.append(a)
print((len(numList)))

# Optimized solution
from collections import Counter
n=int(eval(input()))
a=[int(eval(input())) for i in range(n)]
cnt=Counter(a)
print((len(tuple(i for i in list(cnt.values()) if i%2==1))))
# Original solution
n=int(eval(input()))
mydict={}

for i in range(n):
  a=int(eval(input()))
  if a in mydict:
    if mydict[a]==1:
      mydict[a]=0
    else:
      mydict[a]=1
  else:
    mydict[a]=1
    
#print(mydict)
mylist=list(mydict.values())

print((sum(mylist)))


# Optimized solution
mydict={}
n=int(eval(input()))

#print(n,a)
for i in range(n):
  a=eval(input())
  if a in mydict:
    del mydict[a]
  else:
    mydict[a]=1
    
print((len(mydict)))
# Original solution
numbers = {}
for _ in [0] * int(eval(input())):
    A = int(eval(input()))
    numbers[A] = numbers.get(A, 0) ^ 1
print((sum(numbers.values())))

# Optimized solution
nums = set()
for _ in [0] * int(eval(input())):
    A = int(eval(input()))
    if A in nums:
        nums.remove(A)
    else:
        nums.add(A)
print((len(nums)))
# Original solution
n = int(eval(input()))
d = {}
l = []

for i in range(n):
    a = int(eval(input()))
    if a not in l:
        l.append(a)
        d.update({a:1})
    else:
        if d[a] == 0:
            d[a] = 1
        else:
            d[a] = 0

ans = len(l)
for i in range(len(l)):
    if d[l[i]] == 0:
        ans -= 1
print(ans)

# Optimized solution
n = int(eval(input()))
A = []

for i in range(n):
    a = int(eval(input()))
    A.append(a)
A.sort()
i = 0
ans = 0
while True:
    cnt = 0
    while A[i + cnt] == A[i]:
        cnt += 1
        if i + cnt == n:
            break
    if cnt%2 == 1:
        ans += 1
    i += cnt
    if i == n:
        break
print(ans)
# Original solution
n=int(eval(input()))
a=[]
for i in range(n):
    k=int(eval(input()))
    if k not in a:
        a.append(k)
    elif k in a:
        a.remove(k)
print((len(a)))

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

ptr=0
res=0
while ptr<n:
    cc=a[ptr]
    f=0
    while ptr<n and a[ptr]==cc: #出現回数をカウント
        f+=1
        ptr+=1
    res+=f%2 #奇数回の場合インクリメント
print(res)
# Original solution
def main():
    n = int(eval(input()))
    a = list()
    for i in range(n):
        m = eval(input())
        if m in a:
            a.remove(m)
        else:
            a.append(m)
    print((len(a)))


if __name__ == "__main__":
    main()


# Optimized solution
def main():
    n = int(eval(input()))
    a = set()
    for i in range(n):
        m = eval(input())
        if m in a:
            a.remove(m)
        else:
            a.add(m)
    print((len(a)))


if __name__ == "__main__":
    main()
# Original solution
N = int(eval(input()))
d = dict()
for _ in range(N):
    a = int(eval(input()))
    d[a] = d.get(a, 0) ^ 1
print((sum(d.values())))

# Optimized solution
N, *A = list(map(int, open(0).read().split()))
d = dict()
for a in A:
    d[a] = d.get(a, 0) ^ 1
print((sum(d.values())))
# Original solution
n=int(eval(input()))
a=[]
ans=[]
for i in range(n):
    b=eval(input())
    a+=[b]
for i in range(n):
    if a[i] in ans:
        ans.remove(a[i])
    else:
        ans.append(a[i])
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()))
num = [int(eval(input())) for _ in range(n)]
ans = 0

for i in set(num):
    if num.count(i)%2 == 1:
        ans += 1

print(ans)


# Optimized solution
n = int(eval(input()))
a = sorted([int(eval(input())) for _ in range(n)])
ans = 0
count = 0
pre = a[0]

for i in range(n):
    if a[i] == pre:
        count+=1
    else:
        pre = a[i]
        if count%2 == 1:
            ans += 1
        count = 1
if count%2 == 1:
    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()))

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

print(ans)
# Original solution

def read_input():
    n = int(eval(input()))
    alist = []

    for i in range(n):
        alist.append(int(eval(input())))

    return n, alist


def submit():
    n, alist = read_input()

    paper = {}
    for a in alist:
        if a not in list(paper.keys()):
            paper[a] = 1
        else:
            paper[a] *= -1

    paper_write = [t for t in list(paper.items()) if t[1] == 1]
    print((len(paper_write)))

if __name__ == '__main__':
    submit()

# Optimized solution

def read_input():
    n = int(eval(input()))
    alist = []

    for i in range(n):
        alist.append(int(eval(input())))

    return n, alist


def submit():
    n, alist = read_input()

    paper = {a: -1 for a in alist}

    for a in alist:
        paper[a] *= -1

    paper_write = [t for t in list(paper.items()) if t[1] == 1]
    print((len(paper_write)))

if __name__ == '__main__':
    submit()
# Original solution
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: list(map(int, sys.stdin.readline().split()))
nl = lambda: list(nm())

n = ni()

a = []
for i in range(n):
    tmp = ni()
    if tmp in a:
        a.pop(a.index(tmp))
    else:
        a.append(tmp)
print((len(a)))


# Optimized solution
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: list(map(int, sys.stdin.readline().split()))
nl = lambda: list(nm())

n = ni()

a = [ni() for _ in range(n)]
c = list(collections.Counter(a).values())
ans = 0
for t in c:
    if t % 2 != 0:
        ans += 1
print(ans)
# Original solution
N = int(eval(input()))
x=int(eval(input()))
y=[x]

i=1
while i < N:
    x=int(eval(input()))
    a=0
    flag=1
    while a < len(y):
        if y[a]==x:
            del y[a]
            flag=-1
            break
        a+=1
    if flag==1:
        y.append(x)
    i+=1

print((len(y)))


# Optimized solution

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

x.sort()
i=0
while i < N-1:
    if x[i]==x[i+1]:
        del x[i+1]
        del x[i]
        N-=2
        continue
    i+=1
print((len(x)))
# Original solution
n = int(eval(input()))
lis = []
for i in range(n):
    a = int(eval(input()))
    if a not in lis:lis.append(a)
    else:lis.remove(a)
print((len(lis)))

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