CodeEff/ECCO huggingface dataset:
# Original solution
n=int(eval(input()))
a=[int(eval(input()))for i in range(n)]
import collections
data=collections.Counter(a)
count=0
for i,j in list(data.items()):
    if j%2==1:
        count+=1
print(count)

# Optimized solution
n=int(eval(input()))
a=[int(eval(input()))for i in range(n)]
from collections import Counter
ans=[0]*n
for i in range(n):
    ans[i]=a[i]
data=Counter(ans)
cnt=0
for i in list(data.values()):
    if i%2==1:
        cnt+=1
print(cnt)
# Original solution

if __name__ == '__main__':
    N=int(eval(input()))
    sheet=[]
    for i in range(N):
        temp=int(eval(input()))
        sheet.append(temp)

    sheet.sort()
    count=0
    for i in range(len(sheet)):
        number=sheet.count(sheet[i])
        if number%2==1:
            count+=1

    print(count)

# Optimized solution

if __name__ == '__main__':
    N=int(eval(input()))
    sheet=[]
    for i in range(N):
        temp=int(eval(input()))
        sheet.append(temp)
    sheet.sort()
    count=0
    i=0
    while i<N:
        s=sheet[i]
        j=i
        while i<N and sheet[i]==s:
            i+=1
        d=i-j
        if d%2==1:
            count+=1

    print(count)
# Original solution

if __name__ == '__main__':
    N=int(eval(input()))
    sheet=[]
    for i in range(N):
        temp=int(eval(input()))
        sheet.append(temp)
    sheet.sort()
    count=0
    i=0
    while i<N:
        s=sheet[i]
        j=i
        while i<N and sheet[i]==s:
            i+=1
        d=i-j
        if d%2==1:
            count+=1

    print(count)

# Optimized solution

if __name__ == '__main__':
    N=int(eval(input()))
    sheet=set()
    for i in range(N):
        temp=int(eval(input()))
        if temp in sheet:
            sheet.remove(temp)
        else:
            sheet.add(temp)
    print((len(sheet)))
# Original solution
import collections
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
c = collections.Counter(A)
ans = 0
for i in range(len(c)):
    ans += c.most_common()[i][1] % 2
print(ans)

# Optimized solution
import collections
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
c = collections.Counter(A).most_common()
ans = 0
for i in range(len(c)):
    ans += c[i][1] % 2
print(ans)
# Original solution
def solution():
	n = int(eval(input()))
	l = []
	for i in range(n):
		x = int(eval(input()))
		if x in l:
			del l[l.index(x)]
		else:
			l.append(x)

	print((len(l)))

solution()

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

	l.sort()

	i = 0
	ans = 0
	while i<(n-1):
		if l[i]==l[i+1]:
			i+=2
		else:
			i+=1
			ans+=1
	if i==n-1:
		ans+=1
			

	print(ans)

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


ds = {}
for _ in range(N):
    A = eval(input())
    if A not in ds:
        ds[A] = 0
    else:
        ds[A] += 1

cnt = 0
for d in ds:
    if ds[d] % 2 == 0:
        cnt += 1

print(cnt)


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


ds = {}
for _ in range(N):
    A = eval(input())
    if A not in ds:
        ds[A] = 0
    else:
        ds[A] += 1

cnt = 0
for d in list(ds.values()):
    if d % 2 == 0:
        cnt += 1
print(cnt)
# Original solution
n = int(eval(input()))
a = []
for i in range(n):
    num = int(eval(input()))
    if num in a:
        a.remove(num)
    else:
        a.append(num)
print((len(a)))


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

# Optimized solution
N=int(eval(input()))
p=[]
count=0
for i in range (N):
  a=int(eval(input()))
  p.append(a)
list.sort(p)
flag=1
for j in range (N-1):
  if p[j]==p[j+1]:
    flag*=-1
  else:
    if flag>0:
      count+=1
    flag=1
if flag>0:
  count+=1
print(count)
# Original solution
# 操作回数を入力する
N = int(eval(input()))
# 言う数字を入力する
list_A = [int(eval(input())) for _ in range(N)]
# 終了後に残っている数字の数を設定する
ans = 0
# 数字の種類のリストを作成する
num_list = list(set(list_A))
# それぞれの数字について、、
for num in num_list:
    # 言われる回数を求める
    count = list_A.count(num)
    # 奇数回言われる場合、ansを増やす
    if count % 2 != 0:
        ans += 1
# 結果を出力する
print(ans)

# Optimized solution
import bisect
# 操作回数を入力する
N = int(eval(input()))
# 言う数字を入力する
list_A = [int(eval(input())) for _ in range(N)]
# 紙の状態を設定する
paper = []
# 
for A in list_A:
    if paper == []:
        paper.append(A)
        continue
    # 紙上のAをニ分探索する
    index = bisect.bisect_left(paper, A)
    if index < len(paper) and paper[index] == A:
        del paper[index]
    else:
        paper.insert(index, A)
# 結果を出力する
print((len(paper)))
# 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()))
A = [int(eval(input())) for _ in range(n)]
S = set()
for a in A:
    if a in S:
        S.remove(a)
    else:
        S.add(a)
print((len(S)))
# Original solution
n = int(eval(input()))
d = {}
for _ in range(n):
  a = int(eval(input()))
  if a not in d: d[a] = 1
  else: d[a] += 1

ans = 0
for i in list(d.values()):
  if i%2 != 0: ans += 1
print(ans)

# Optimized solution
n = int(eval(input()))
d = {}
for _ in range(n):
  a = int(eval(input()))
  if a in d: d[a] += 1
  else: d[a] = 1

ans = 0
for i in list(d.values()):
  if i%2 != 0: ans += 1
print(ans)
# Original solution
N = int(eval(input()))
paper = []
paper.append(1000000001)

for i in range(N):
    # Aのi番目
    ai = int(eval(input()))
    for p in range(len(paper)):
        if paper[p] < ai:
            continue
        elif paper[p] == ai:
            paper.remove(ai)
            break
        else:
            paper.insert(p, ai)
            break

print((len(paper) -1))

# Optimized solution
def main():
    N = int(eval(input()))

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

    # TimSortっていうMergeSortの改良版らしい
    paper.sort()

    preNum = paper[0]
    sameNumCount = 1
    ans = 0
    for num in paper[1:]:
        if preNum == num:
            sameNumCount += 1
        else:
            ans += sameNumCount % 2
            preNum = num
            sameNumCount = 1
    # 一番最後の判定
    if paper[-1] == preNum:
        ans += sameNumCount % 2

    print(ans)

if __name__ == '__main__':
    main()
# Original solution
from collections import Counter
print((sum([a % 2 for a in list(Counter([int(eval(input())) for _ in range(int(eval(input())))]).values())])))

# Optimized solution
from collections import Counter
import sys

def read():
    return sys.stdin.readline().rstrip()

n = int(read())
a = Counter([int(read()) for _ in range(n)])
print((sum([ai % 2 for ai in list(a.values())])))
# Original solution
n = int(eval(input()))
a = [int(eval(input())) 
     for nesya in range(n)]
s = set(a)
b = list(sorted(s))
ans = 0
for i in range(len(b)):
  c = a.count(b[i])
  if c%2 == 1:
    ans += 1
  a = [j for j in a if j > b[i]]
print(ans)

# Optimized solution
n = int(eval(input()))
a = [int(eval(input())) 
     for nesya in range(n)]
s = set()
for b in a:
  if b in s:
    s.discard(b)
  else:
    s.add(b)
print((len(s)))
# Original solution
import collections
n = int(eval(input()))
c = collections.Counter([int(eval(input())) for _ in range(n)])
ans = 0
for cnt in list(c.values()):
    if cnt %2 != 0:
        ans += 1
print(ans)

# Optimized solution
import collections
n = int(eval(input()))
c = collections.Counter([int(eval(input())) for _ in range(n)])
print((sum([1 for cnt in list(c.values()) if cnt %2 != 0])))
# Original solution
N=int(eval(input()))
Sister=[int(eval(input())) for i in range(N)]
set_Sister=set(Sister)
Paper=0
for i in set_Sister:
  if Sister.count(i)%2==1:
    Paper+=1
print(Paper)

# Optimized solution
N=int(eval(input()))
Sister={}
Paper=0
for i in range(N):
  index=int(eval(input()))
  if index not in Sister:
    Sister[index]=1
  else:
    Sister[index]+=1
for i in Sister:
  if Sister[i]%2==1:
    Paper+=1
print(Paper)
# Original solution
n = int(eval(input()))
a = [eval(input()) for _ in range(n)]
sa = set(a)
res = 0
for i in sa:
    if a.count(i)%2!=0:
        res+=1

print(res)


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

p = set()
for i in range(N):
    A = eval(input())
    p ^= {A}

print((len(p)))
# Original solution
N = int(eval(input()))
A = [eval(input()) for _ in range(N)]
a = {}
for i in range(N):
  if A[i] in a:
    a[A[i]] += 1
  else:
    a[A[i]] = 1

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

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

p = {}
for a in A:
    if a in p:
        if p[a] == 1:
            p[a] = 0
            continue
    p[a] = 1
ans = 0
for i in list(p.values()):ans += i
print(ans)
# 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()))

s=set()

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

print((len(as_)))

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

# Optimized solution
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
a.sort()
d = [1]
for i in range(n-1):
    if a[i] != a[i+1]:
        d.append(1)
    else:
        d[-1] += 1
ans = 0
for i in d:
    ans += i%2
print(ans)
# Original solution
import collections
n = int(eval(input()))
ls = [int(eval(input())) for i in range(n)]
ls.sort()
c = collections.Counter(ls)
p = 0
for j in range(len(c)):
    if c.most_common()[j][1] % 2 ==0:
        continue
    else:
        p += 1
print(p)

# Optimized solution
import collections
n = int(eval(input()))
ls = [int(eval(input())) for i in range(n)]
ls.sort()
c = collections.Counter(ls)
d = list(c)
p = 0
for j in range(len(c)):
    if c[d[j]] % 2 ==0:
        continue
    else:
        p += 1
print(p)
# Original solution
from sys import stdin
from collections import Counter

n, *a = (int(x) for x in stdin.read().split())

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

print(count)

# Optimized solution
import sys
from collections import Counter

n, *a = list(map(int, sys.stdin.read().split()))

def main():
    res = 0
    for c in list(Counter(a).values()):
        res += c & 1

    return res

if __name__ == '__main__':
    ans = main()
    print(ans)
# Original solution
N = int(eval(input()))

A = []
for i 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 = []
for i in range(N):
    A.append(int(eval(input())))

B = set()

for a in A:
    if a in B:
        B.remove(a)
    else:
        B.add(a)

print((len(B)))
# Original solution
n =int(eval(input()))
A = {0}
for i in range(n):
  a = {int(eval(input()))}
  if i==0:
    A = A|a
  else:
    A = A^a
print((len(A)-1))


# Optimized solution
n =int(eval(input()))
A = set()
for i in range(n):
  A ^= {int(eval(input()))}
print((len(A)))
# Original solution
import collections

N = int(eval(input()))
A = list([int(eval(input())) for _ in range(N)])
A = list(collections.Counter(A).values())

ans = [x for x in A if x&1]
print((len(ans)))

# Optimized solution
import collections
N = int(eval(input()))
A = collections.Counter([int(eval(input())) for _ in range(N)])
A = list(A.values())
ans = [x for x in A if x&1]
print((len(ans)))
# Original solution
from collections import Counter

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

A = Counter(A)
num = []
for a in list(A.items()):
    if a[1]%2 != 0:
        num.append(a[0])

print((len(set(num))))

# Optimized solution
from collections import Counter

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

D = Counter(A)
res = 0
for v in list(D.values()):
    if v%2 != 0:
        res += 1

print(res)
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
array = []
ans = 0

for i in range(N):
  if A[i] not in array:
    array.append(A[i])
    if A.count(A[i]) % 2 == 1:
      ans += 1
print(ans)


# Optimized solution
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
array = []
ans = 0
A.sort()
count = 0

for i in range(N):
  count += 1
  if i == N-1:
    if count%2 == 1:
      ans += 1
#    print(A[i], count, ans)
    
#  elif A[i] == A[i+1]:
#    print(A[i], count, ans)
    
  elif A[i] != A[i+1]:
    if count % 2 == 1:
      ans += 1
#    print(A[i], count, ans)
    count = 0

print(ans)
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
array = []
ans = 0
A.sort()
count = 0

for i in range(N):
  count += 1
  if i == N-1:
    if count%2 == 1:
      ans += 1
#    print(A[i], count, ans)
    
#  elif A[i] == A[i+1]:
#    print(A[i], count, ans)
    
  elif A[i] != A[i+1]:
    if count % 2 == 1:
      ans += 1
#    print(A[i], count, ans)
    count = 0

print(ans)

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

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

    if a in l:
        l.remove(a)
    else:
        l.append(a)

print((len(l)))


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

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

    if a in l:
        l.remove(a)
    else:
        l.add(a)

print((len(l)))
# Original solution
import sys
input = sys.stdin.readline
N=int(eval(input()))
ans=[]

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


print((len(ans)))


# Optimized solution
import sys
input = sys.stdin.readline
N=int(eval(input()))
ans=dict()
cnt=0

for _ in range(N):
    A=int(eval(input()))
    if((A in ans)==False):
        ans[A]=1
    else:
        ans[A]+=1

for value in list(ans.values()):
    if(value%2==1):
        cnt+=1

print(cnt)
# Original solution
def myAnswer(N:int,A:list) -> int:
   ans = []
   for a in A:
      if(a in ans):
         ans.remove(a)
      else:
         ans.append(a)
   return len(ans)

def modelAnswer():
   return
def main():
   N = int(eval(input()))
   A = [int(eval(input())) for _ in range(N)]
   print((myAnswer(N,A[:])))
if __name__ == '__main__':
   main()

# Optimized solution
def myAnswer(N:int,dic:dict) -> int:
   ans = 0
   for a in list(dic.values()):
      if(a % 2 == 1):
         ans += 1
   return ans

def modelAnswer():
   return
def main():
   N = int(eval(input()))
   dic = {}
   for _ in range(N):
      a = int(eval(input()))
      if(a in list(dic.keys())):
         dic[a]+=1
      else:
         dic[a]=1
   print((myAnswer(N,dic)))
if __name__ == '__main__':
   main()
# Original solution
def myAnswer(N:int,dic:dict) -> int:
   ans = 0
   for a in list(dic.values()):
      if(a % 2 == 1):
         ans += 1
   return ans

def modelAnswer():
   return
def main():
   N = int(eval(input()))
   dic = {}
   for _ in range(N):
      a = int(eval(input()))
      if(a in list(dic.keys())):
         dic[a]+=1
      else:
         dic[a]=1
   print((myAnswer(N,dic)))
if __name__ == '__main__':
   main()

# Optimized solution
import sys
input = sys.stdin.readline

def myAnswer(N:int,dic:dict) -> int:
   ans = 0
   for a in list(dic.values()):
      if(a % 2 == 1):
         ans += 1
   return ans

def modelAnswer():
   return
def main():
   N = int(eval(input()))
   dic = {}
   for _ in range(N):
      a = int(eval(input()))
      if(a in list(dic.keys())):
         dic[a]+=1
      else:
         dic[a]=1
   print((myAnswer(N,dic)))
if __name__ == '__main__':
   main()
# Original solution
N = eval(input())
N = int(N)

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

print((len(a)))

# Optimized solution
n=int(input())
li={}
while n !=0:
    a = input()
    if a in li:
        del li[a]
    else:
        li[a]=a
    n-=1
print((len(li)))
# Original solution
N = int(eval(input()))
Result = []
for i in range(N):
    number = int(eval(input()))
    if  number in Result:
        Result.remove(number)
    else:
        Result.append(number)
print((len(Result)))

# Optimized solution
N = int(eval(input()))
Result = set()
for i in range(N):
    number = int(eval(input()))
    if  number in Result:
        Result.remove(number)
    else:
        Result.add(number)
print((len(Result)))
# Original solution
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
each_a = set(a)
count = 0
for i in each_a:
    if a.count(i) % 2 == 1:
        count += 1
print(count)

# Optimized solution
N = int(eval(input()))
a = {}
for i in range(N):
    j = int(eval(input()))
    if j in a:
        a[j] += 1
    else:
        a[j] = 1
count = 0
for v in list(a.values()):
    if v % 2 == 1:
        count += 1
print(count)
# Original solution
n=int(eval(input()))
a=[int(eval(input()))for i in range(n)]
print((len(set([i for i in a if a.count(i)%2!=0]))))

# Optimized solution
n=int(eval(input()))
a=[int(eval(input()))for i in range(n)]
a.sort()
memo=a[0]
ans=0
cnt=0
for i in range(n):
    if a[i]==memo:
        cnt+=1
        if i==n-1:
            if cnt%2!=0:
                ans+=1
    else:
        if cnt%2!=0:
            ans+=1
        if i==n-1:
            ans+=1
        cnt=1

    memo=a[i]
print(ans)
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
A.sort()

index = 0
result = 0
while True:
    num = A.count(A[index])
    index += num
    if (num % 2) == 1:
        result += 1
    if N <= index:
        break
print(result)

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


def customCount(idx):
    target = A[idx]
    cnt = 1
    idx += 1
    while True:
        if idx == N or A[idx] != target:
            return cnt
        else:
            idx += 1
            cnt += 1


index = 0
result = 0
while True:
    num = customCount(index)
    index += num
    if (num % 2) == 1:
        result += 1
    if N <= index:
        break
print(result)
# Original solution
n=int(eval(input()))
l=[]
for i in range(n):
    s=int(eval(input()))
    if s in l:
        l.pop(l.index(s))
    else:
        l.append(s)
print((len(l)))

# Optimized solution
n=int(eval(input()))
s=set()
for i in range(n):
    s^={eval(input())}
print((len(s)))
# Original solution
import sys
n=int(eval(input())) #　a1
lap = [int(eval(input())) for i in range(n)]


ppsum=[]

def delap(ap,psum):
  if len(ap)==0:
    print((len(psum)))
    sys.exit(0)
  a=ap[0]

  if ap.count(a)%2 != 0:
    psum.append(a)

  ap=[i for i in ap if i!=a  ]
  delap(ap,psum)

delap(lap,ppsum)

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

ans = [eval(input()) for i in range(n)]

ans.sort()

s = sorted(set(ans))
t = 0
cnt = 0

result = 0
for i in range(n):
    temp = s[t]
    if ans[i] == temp:
        cnt += 1
    else:
        if cnt % 2 == 1:
            result += 1
        cnt = 1
        t += 1
else:
    if cnt % 2 == 1:
        result += 1
        
    
    

print(result)

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

# Optimized solution
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
A.sort()
count = 0
a = -1
a_count = 0
for i in range(N):
    if a!=A[i]:
        count+=1
        a_count=1
    elif a_count%2==1:
        count-=1
        a_count+=1
    else:
        count+=1
        a_count+=1
    a=A[i]
print(count)
# Original solution
n = int(eval(input()))
nums = set()

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

    try:
        nums.remove(a)
    except KeyError:
        nums.add(a)

print((len(nums)))


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

for i in range(n):
    a = int(eval(input()))
    times[a] = times.get(a, 0) + 1

cnt = 0

for i in times:
    if times[i]%2 == 1:
        cnt += 1

print(cnt)
# Original solution
n=int(eval(input()))
al=[int(eval(input())) for _ in range(n)]

setal=set(al)
ans=0
for seta in setal:
    if al.count(seta)%2 == 1:
        ans+=1

print(ans)

# Optimized solution
n=int(eval(input()))
s=set()
for _ in range(n):
    a = eval(input())
    if a in s:
        s.remove(a)
    else:
        s.add(a)
print((len(s)))
# Original solution
from collections import Counter

n = int(eval(input()))
ans = 0

A = Counter((int(eval(input())) for _ in range(n)))

for j in list(A.values()):
  if j%2 != 0:
    ans += 1
print(ans)

# Optimized solution
from collections import Counter

def main():
  n = int(eval(input()))
  ans = 0
  A = Counter((int(eval(input())) for _ in range(n)))
  for i in list(A.values()):
    if i%2 != 0:
      ans += 1
  print(ans)

if __name__=='__main__':
  main()
# Original solution
n=int(eval(input()))
num=[]
def ap(num1):
    num.append(num1)
def rm(num2):
    num.remove(num2)
for i in range(n):
    a=int(eval(input()))
    str=a in num
    if str==True:
        rm(a)
    else:
        ap(a)
print((len(num)))


# Optimized solution
n=int(eval(input()))
num=[]
def ap(num1):
    num.append(num1)
for i in range(n):
    a=int(eval(input()))
    ap(a)
num.sort()
num1=num[0]
num2=1
ans=0
for i in range(n-1):
    if num[i+1]==num1:
        num2+=1
    else:
        num1=num[i+1]
        if num2%2==1:
            ans+=1
        num2=1
if num2%2==1:
    ans+=1
print(ans)
# Original solution
from collections import Counter
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
c = Counter(A)
print((sum(tuple([x % 2 for x in list(c.values())]))))

# Optimized solution
import sys
from collections import Counter
input = sys.stdin.readline
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
c = Counter(A)
print((sum([x % 2 for x in list(c.values())])))
# Original solution
n = int(eval(input()))
ans = 0
dic1 = dict()
for i in range(n):
    a = int(eval(input()))
    if a in dic1:
        dic1[a] += 1
    else:
        dic1[a] = 1
for i in list(dic1.values()):
    ans += i%2
print(ans)

# Optimized solution
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

dic1 = dict()

n = int(readline())
for i in range(n):
    a = int(readline())
    if a in dic1:
        dic1[a] += 1
    else:
        dic1[a] = 1

ans = 0
for i in list(dic1.values()):
    if not even(i):
        ans += 1
print(ans)
# Original solution
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
setA = set(A)
B = len([A.count(i) for i in setA if A.count(i) % 2 != 0])
print(B)

# Optimized solution
N = int(eval(input()))
A = {}
for i in range(N):
    a = int(eval(input()))
    A.setdefault(a, 0)
    if a in A:
        A[a]+=1
count = 0
for v in list(A.values()):
    if v%2!=0:
        count += 1
print(count)
# Original solution
N = int(eval(input()))
A = {}
for i in range(N):
    a = int(eval(input()))
    A.setdefault(a, 0)
    if a in A:
        A[a]+=1
count = 0
for v in list(A.values()):
    if v%2!=0:
        count += 1
print(count)

# Optimized solution
N = int(eval(input()))
cnt = 0
A = {}
for i in range(N):
    a = int(eval(input()))
    if a not in A:
        A[a] = 1
        cnt += 1
    else:
        A.pop(a)
        cnt -= 1
print(cnt)