You are playing the following game with Joisino.
 - Initially, you have a blank sheet of paper.
 - Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
 - Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?

-----Constraints-----
 - 1≤N≤100000
 - 1≤A_i≤1000000000(=10^9)
 - All input values are integers.

-----Input-----
Input is given from Standard Input in the following format:
N
A_1
:
A_N

-----Output-----
Print how many numbers will be written on the sheet at the end of the game.

-----Sample Input-----
3
6
2
6

-----Sample Output-----
1

The game proceeds as follows:
 - 6 is not written on the sheet, so write 6.
 - 2 is not written on the sheet, so write 2.
 - 6 is written on the sheet, so erase 6.
Thus, the sheet contains only 2 in the end. The answer is 1.

Difficulty: introductory

Starter code:

Solutions:
n=int(input())
d=dict()
for _ in range(n):
    hoge=int(input())
    if d.get(hoge,0)==0:
        d[hoge]=1
    else:
        d[hoge]+=1
ans=0
for i in d.values():
    if i%2==1:
        ans+=1
print(ans)

import collections

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

c = collections.Counter(arr)
ans = 0
for v in c.values():
  if v % 2:
    ans += 1
print(ans)

#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from math import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())
n = I()
dic = defaultdict(int)
for i in range(n):
    a = I()
    dic[a] += 1
ans = 0
for k,v in list(dic.items()):
    ans += v%2
print(ans)


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

d = {}
#key設定
for i in A:
    d[i]=0
#数字keyが偶数回出たら0,奇数回出たら1になるようにvalueを設定
for i in A:
    if d[i]==1:
        d[i]=0
    else:
        d[i]=1
    
print(sum(d.values()))

from collections import Counter
N=int(input())
A=[int(input()) for i in range(N)]

cnt=Counter(A)
ans=0
for k,v in cnt.items():
    if v%2==1:
        ans+=1

print(ans)

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

c = {}
ans = 0

for i in A:
    if i not in c.keys():
        c[i] = 0
    c[i] += 1
    
for j in c.values():
    if j % 2 ==1:
        ans += 1

#print(A)
#print(c)
print(ans)

import collections
n = int(input())
l = list(int(input()) for i in range(n))
d = collections.Counter(l)
ans = 0
for v in d.values():
  ans += v % 2
print(ans)

N = int(input())
A = [0]*N

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

A.sort()

count = 1
ans = 0
for i in range(N-1):
  if A[i] == A[i+1]:
    count+=1
  else:
    ans+=count%2
    count=1

ans+=count%2

print(ans)

# -*- coding: utf-8 -*-

N =int(input())
A = {}
for i in range(N):
    val = int(input())
    if val in A:
        A[val] += 1
    else:
        A[val] = 1

ans = 0
for k, v in A.items():
    if v % 2 != 0:
        ans += 1

print(ans)

from collections import Counter
n = int(input())
ans = 0
C = Counter(int(input()) for _ in range(n))
for c in list(C.values()):
    if c % 2 == 1:
        ans += 1
print(ans)


from sys import stdin, stdout # only need for big input


def solve():
    n = int(input())
    st = set()
    for _ in range(n):
        a = int(input())
        if a in st:
            st.remove(a)
        else:
            st.add(a)
    print(len(st))

def main():
    solve()


def __starting_point():
    main()
__starting_point()

from collections import  Counter

n = int(input())
A = [int(input()) for _ in range(n)]
cnt_A = Counter(A)

ans = 0
for v in cnt_A.values():
    if v % 2 == 1:
        ans += 1
print(ans)

from collections import defaultdict

d = defaultdict(int)

n = int(input())
for i in range(n):
  a = int(input())
  d[a] = int(not(d[a]))
ans=0
for k,v in d.items():
  if v == 1:
    ans += 1

print(ans)

n = int(input())
kami = set()

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

print((len(kami)))


import collections
n=int(input())
a=[int(input()) for i in range(n)]
print(sum([i%2==1 for i in collections.Counter(a).values()]))

# coding: utf-8


def main():
    N = int(input())
    ans = 0
    dic = {}
    for _ in range(N):
        a = int(input())
        if a not in list(dic.keys()):
            dic[a] = 1
            ans += 1
        elif dic[a] == 0:
            dic[a] += 1
            ans += 1
        else:
            dic[a] -= 1
            ans -= 1

    print(ans)

def __starting_point():
    main()

__starting_point()

N = int(input())
ans = {}
for i in range(N):
    A = input()
    if  A in ans:
        ans[A] += 1
    else:
        ans[A] = 1
c = 0
for i in ans:
    if ans[i] % 2 == 1:
        c += 1
print(c)

# -*- coding: utf-8 -*-
"""
Created on Wed Sep 23 16:50:38 2020

@author: liang
"""
N = int(input())
d = dict()
ans = 0 
A = [int(input()) for _ in range(N)]
for a in A:
    if a in d:
        d[a] += 1
    else:
        d[a] = 1
#print(d)
for key in d.keys():
    if d[key] %2 ==1:
        ans += 1
        d[key] = 0
#print(d)
print(ans)

from collections import Counter
N = int(input())
A = [int(input()) for _ in range(N)]
cnt = dict(Counter(A))
ans = []
for k, v in list(cnt.items()):
    if v % 2 != 0:
        ans.append(k)
print((len(ans)))


from collections import Counter

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

print(sum(c%2 for c in Counter(A).values()))

import collections

n = int(input())
a = [int(input()) for _ in range(n)]
c = collections.Counter(a)

cnt = 0
for x in c.values():
    if x % 2 == 1:
        cnt += 1
print(cnt)

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

dic = {}

for i in range(N):
  if A[i] in dic.keys():
    dic[A[i]] += 1
  else:
    dic[A[i]] = 1
    
cnt = 0

for j in dic.keys():
  if dic[j] % 2 == 1:
    cnt += 1
    
print(cnt)

# 20
n = int(input())
a = {}
cnt = 0

for i in range(n):
    num = int(input())
    a[num] = a.get(num,0)+1
    a[num] %= 2
    
for i in a.values():
    cnt += i



print(cnt)

import collections 
N = int(input())
lsA = []
for i in range(N):
    lsA.append(int(input()))
counterA = collections.Counter(lsA)
ans = 0
for i in counterA.values():
    ans += i%2
print(ans)

N = int(input())
numbers = {}
for i in range(N):
    x = int(input())
    if x in numbers:
        del numbers[x]
    else:
        numbers[x] = 1
print(len(numbers))

n = int(input())
li = set()

for i in range(n):
    x = int(input())
    if x in li:
        li.remove(x)
    else:
        li.add(x)
print((len(li)))


n = int(input())
a = list()
for i in range(n):
    a.append(int(input()))
import collections
b = collections.Counter(a)
c = list(map(lambda x: x%2, list(b.values())))
print(c.count(1))

N = int(input())
S = set()
for _ in range(N):
  a = int(input())
  if a in S:
    S.remove(a)
  else:
    S.add(a)
    
print((len(S)))


n = int(input())
a = []
for i in range(n):
  a.append(int(input()))
a.sort()
jud = 1
q = a[0]
ans = 0
for i in range(1,n):
  if(q==a[i]):
    jud += 1
  else: 
    if(jud%2==1):
      ans += 1
    jud = 1
    q = a[i]
if (jud%2==1):
  ans += 1
if(n==1):
  ans = 1
print(ans)


from collections import Counter
n = int(input())
a = []
for i in range(n):
  a.append(int(input()))
a = dict(Counter(a))
count = 0
for i in a.values():
    if i % 2 == 1:
        count += 1
print(count)

#!/usr/bin/env python

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

d = {}
for i in range(n):
    if a[i] not in d:
        d[a[i]] = 1 
    else:
        d[a[i]] += 1

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

print(ans)


n=int(input())
s=set()
for i in range(n):
    a=int(input())
    if a in s:
        s.remove(a)
    else:
        s.add(a)
print(len(s))

N = int(input())
A = [int(input()) for _ in range(N)]
dic = {num: 0 for num in set(A)}
for i in range(N):
    dic[A[i]] = 1 if dic[A[i]]==0 else 0
ans = 0
for num in set(A):
    ans += dic[num]
print(ans)

N = int(input())
num = {}
for i in range(N):
    A = int(input())
    if A in list(num.keys()):
        num[A] += 1
    else:
        num[A] = 1
ans = 0
for i, j in list(num.items()):
    if j%2 == 1:
        ans += 1
print(ans)


n = int(input())
paper = dict()
for i in range(n):
    a = int(input())
    if a not in paper:
        paper[a] = 1
    else:
        paper.pop(a)

res = 0
for value in list(paper.values()):
    if value == 1:
        res += 1
print(res)


import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
l = [int(input()) for _ in range(N)]

c = Counter(l)

ans = 0
for i, j in zip(list(c.keys()), list(c.values())):
    if j % 2 != 0:
        ans += 1

print(ans)


import collections
n = int(input())
alist = [int(input()) for i in range(n)]
cole = collections.Counter(alist)
count = 0
for i in cole.values():
  if i%2==1:
    count+=1
print(count)

n = int(input())
A = [int(input()) for _ in range(n)]
a = sorted(A)
i = 0
ans = 0
while i < n:
    if i == 0:
        if a[0] == a[1]:
            cnt = 2
            i = 2
            while i < n and a[i-1] == a[i]:
                cnt += 1
                i += 1
            ans += cnt%2
        else:
            ans += 1
            cnt = 1
            i = 2
            while i < n and a[i-1] == a[i]:
                cnt += 1
                i += 1
            ans += cnt%2
    else:
        cnt = 1
        i += 1
        while i < n and a[i-1] == a[i]:
            cnt += 1
            i += 1
        ans += cnt%2
print(ans)

n = int(input())
a = [int(input()) for _ in range(n)]
s = set()
for x in a:
  if x in s:
    s.remove(x)
  else:
    s.add(x)
print(len(s))

from collections import defaultdict
d = defaultdict(int)
n = int(input())
for i in range(n):
    a = int(input())
    if d[a] > 0:
        d[a] -= 1
    else:
        d[a] += 1

ans = 0
for v in list(d.values()):
    if v > 0:
        ans += 1
print(ans)


P = set()
N = int(input())
for i in range(N):
  A = int(input())
  if A in P:
    P.remove(A)
  else:
    P.add(A)
print(len(P))

n=int(int(input()))
s=set()
for i in range(n):
    s^= set([input()])
print(len(s))

import sys
mod=10**9+7 ; inf=float("inf")
from math import sqrt, ceil
from collections import deque, Counter, defaultdict #すべてのkeyが用意されてる defaultdict(int)で初期化
input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP,Decimal  #変換後の末尾桁を0や0.01で指定
  #Decimal((str(0.5)).quantize(Decimal('0'), rounding=ROUND_HALF_UP))
from functools import lru_cache
from bisect import bisect_left as bileft, bisect_right as biright
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########

n=int(input())
A=[int(input()) for i in range(n)]
C=Counter(A)
print(len([i for i in C.values() if i%2==1]))

import collections
n = int(input())
aa = [int(input()) for a in range(n)]

caa = collections.Counter(aa) # couter aa
cnt = 0
laa = [x[1] for x in caa.items()]
for la in laa:
  if la % 2 == 1:
    cnt += 1
print(cnt)

n = int(input())
A = {}
for i in range(n):
    a = int(input())
    A[a] = A.get(a, 0)+1
    A[a] %= 2
s = 0
for v in list(A.values()):
    s += v
print(s)


N=int(input())
A=dict()
for _ in range(N):
    a=int(input())
    if a not in A:
        A[a]=0
    A[a]=1-A[a]
print((sum(A.values())))


import collections
a = int(input())
s = [input() for i in range(a)]
c = collections.Counter(s)
b = []
for myvalue in list(c.values()):
    b.append(myvalue)

d = len(b)
ans = int(0)
for i in range(int(d)):
    if b[i] % 2 == 0:
        pass
    else:
        ans += 1
        
print(ans)
    


n=int(input())
a=[]
for i in range(n):
    a.append(int(input()))
a=sorted(a)
ans=0
cnt=1
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)


N=int(input())
A=[]
for n in range(N):
    A.append(int(input()))

A.sort()

cnt=1
ans=0
for n in range(1,N):
    if A[n]==A[n-1]:
        cnt+=1
    else:
        if cnt%2==1:
            ans+=1
        cnt=1
    if n==N-1 and cnt%2==1:
        ans+=1
print(ans)

#!/usr/bin/env python3
import sys


def solve(N: int, A: "List[int]"):
    from collections import Counter    
    return sum([x%2==1 for x in list(Counter(A).values())])

# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    print((solve(N, A)))

def test():
    import doctest
    doctest.testmod()

def __starting_point():
    #test()
    main()

__starting_point()

import collections
n = int(input())
x = [int(input()) for i in range(n)]
c = collections.Counter(x)
cc = list(c.values())
cnt = 0
for i in range(len(cc)):
    if cc[i] % 2 == 1:
        cnt += 1
print(cnt)

from collections import Counter
n = int(input())
a = [int(input()) for i in range(n)]
c = Counter(a).values()
ans = 0
for i in c:
    if i % 2 == 1:
        ans += 1
print(ans)

n=int(input())
a={}
for i in range(n):
  a_=int(input())
  if a_ not in a:
    a[a_]=1
  else:
    a[a_]+=1
ans=0
for i in a:
  if a[i]%2==1:
    ans+=1
print(ans)

#20 C - Write and Erase
N = int(input())
A = [int(input()) for _ in range(N)]

paper = set()
for a in A:
    if not(a in paper):
        paper.add(a)
    else:
        paper.remove(a)
print(len(paper))

n = int(input())
sum = 0
nums = {}

for _ in range(n):
    a = input()
    if a not in nums:
        nums[a] = 1
    else:
        nums[a] += 1

for i in list(nums.values()):
    sum += i % 2

print(sum)


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

import collections

c = collections.Counter(A)

print(sum([1 for x in c.values() if x%2==1]))

n=int(input())
a=set()
for i in range(n):
  x=int(input())
  if x in a:
    a.discard(x)
  else:
    a.add(x)

print(len(a))

N=int(input())
d={}
for _ in range(N):
  a=int(input())
  if a in d:
    d[a]+=1
  else:
    d[a]=1
ans=0
for k,v in d.items():
  ans+=v%2
print(ans)

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

from collections import Counter
c = Counter(A)
cc = list(c.values())
ans = 0
for i in range(len(cc)):
    if cc[i] % 2 == 1:
        ans += 1

print(ans)

n=int(input())
d={}
for i in range(n):
  A=int(input())
  if A not in d:
    d[A]=1
  elif d[A]==1:
    d[A]=0
  else:
    d[A]=1
print(sum(d.values()))

# -*- coding: utf-8 -*-
"""
Created on Wed Sep 23 16:58:10 2020

@author: liang
"""


"""
【パディングはソート後】
"""
N = int(input())
A = [int(input()) for _ in range(N)]
A.sort()
A += [-1]
ans = 0
count = 1
for i in range(N):
    #print(count)
    if A[i] == A[i+1]:
        #print("A")
        count += 1
    else:
        #print("B")
        if count%2 == 1:
            ans += 1
        count = 1
print(ans)

import collections
n=int(input())
a=[]
for i in range(n):
   A=int(input()) 
   a.append(A)
c=collections.Counter(a)
ans=0
for i in c:
    if c[i]%2==1:
        ans+=1
print(ans)

n=int(input())

count_dict={}

for i in range(n):
    new=int(input())
    if new in count_dict:
        count_dict[new]+=1
    else:
        count_dict[new]=1
ans=0
for i in count_dict.values():
    if i%2==1:
        ans+=1
print(ans)

N = int(input())
dic = {}

for i in range(N):
    a = int(input())
    
    if a not in dic:
        dic[a] = 1
    else:
        del dic[a]

print(len(dic))

import collections
N = int(input())
A = []
for _ in range(N):
    A.append(int(input()))
    
cnt = collections.Counter(A)
ans = 0
for v in cnt.values():
    if v % 2 != 0:
        ans += 1
        
print(ans)

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

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

def main():
    n = int(input())
    ans = set()
    for _ in range(n):
        a = int(input())
        if a in ans:
            ans.discard(a)
        else:
            ans.add(a)

    print((len(ans)))


def __starting_point():
    main()

__starting_point()

import collections
N=int(input())
A=[]

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

cc=collections.Counter(A)
ans=0
for nums in list(cc.values()):
    if nums%2==1:
        ans+=1
print(ans)

import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: list(map(int, sys.stdin.readline().split()))
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

n = ri()
cnt = 0
for v in list(collections.Counter([ri() for _ in range(n)]).values()):
    if v&1:
        cnt += 1
print(cnt)















n = int(input())
a = []

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

a = sorted(a)

hoge = 0
foo = 0
ans = 0

for i in range(n):
    if i == 0:
        foo = a[i]
        hoge = 1
    elif i == n-1:
        if foo != a[i]:
            if hoge == 1:
                ans += 1
            ans += 1
        else:
            if hoge == 0:
                ans += 1
    elif foo == a[i]:
        hoge = 1-hoge
    else:
        if hoge == 1:
            ans += 1
        foo = a[i]
        hoge = 1

print(ans)


import collections
n=int(input())
a=[0]*n
ans=0
for i in range(n):
    a[i]=input()
c=collections.Counter(a)
l=list(set(a))
for i in range(len(l)):
    if c[l[i]]%2==1:
        ans+=1
print(ans)

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

A.sort()

ans = 0
prev = -1
cnt = 0
for a in A:
    if a == prev:
        cnt += 1
    else:
        ans += cnt % 2
        prev = a
        cnt = 1
else:
    ans += cnt % 2

print(ans)

import collections
import numpy as np
n = int(input())
a = []
for _ in range(n):
    a.append(int(input()))
ans = collections.Counter(a)
c=list(ans.values())
c=np.array(c)
print(sum(c%2))

from collections import defaultdict


N, *A = list(map(int, open(0).read().split()))
ans = defaultdict(int)
for a in A:
    ans[a] += 1
print((sum(v % 2 for v in list(ans.values()))))


import sys
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
from functools import partial, reduce
from collections import Counter


def f_chain(*args):
    return reduce(lambda x, f: f(x), args)

def main():
    n = II()
    aa = [II() for _ in range(n)]
    c_cnt = Counter(aa).values()
    f_chain(c_cnt,
            partial(map, lambda x: 1 if x%2==1 else 0),
            sum,
            print)

def __starting_point():
    main()
__starting_point()

import math
from math import gcd,pi,sqrt
INF = float("inf")

import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return list(map(int, input().split()))
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]

def main():
    n = i_input()
    dic = {}
    for i in range(n):
        a = i_input()
        dic[a] = dic.get(a,0) + 1

    ans = 0

    for i,k in list(dic.items()):
        if k % 2 == 1:
            ans += 1
    print(ans)








def __starting_point():
    main()

__starting_point()

import collections
a=int(input())
b=[int(input()) for i in range(a)]

n=collections.Counter(b)
m,ans=zip(*n.most_common())
ans=[i for i in ans if i%2==1]
print(len(ans))

N = int(input())
A = [int(input()) for c in range(N)]
A = sorted(A)

tmp = 1
cnt = 0
for i in range(N):    
    if i+1<N:
        if A[i] == A[i+1]:
            tmp += 1
        else:
            cnt += tmp%2
            tmp = 1
    else:
        cnt += tmp%2

print(cnt)


n = int(input())
cnt_l = {}
for _ in range(n):
    a = int(input())
    if a in cnt_l:
        cnt_l[a] ^= 1
    else:
        cnt_l[a] = 1
print((sum(cnt_l.values())))


n = int(input())
lis = [0]*n
for i in range(n):
    lis[i] = int(input())

import collections

ans = 0
lis = collections.Counter(lis)

for i in lis.values():
    if i%2 == 1:
        ans += 1

print(ans)

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

i = 0
ans = 0
while i < N:
    tmp = A[i]
    count = 0
    while i < N and A[i] == tmp:
        count += 1
        i += 1
    ans += count % 2

print(ans)


N = int(input())
A = []
count = 1
ans = 0

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

A.sort()

for i in range(N-1):
  if A[i] == A[i+1]:
    count += 1
  else:
    if count%2 == 1:
      ans += 1
    count = 1
else:
  if count%2 == 1:
    ans += 1
  else:
    count = 1

print(ans)

from collections import Counter
print(sum(x % 2 for x in Counter([int(input())
                                  for _ in range(int(input()))]).values()))

import sys
input = sys.stdin.readline
n = int(input())
a = [int(input()) for _ in range(n)]

import collections
c = collections.Counter(a)
cnt = 0

for i,v in list(c.items()):
    if v%2 != 0:
        cnt += 1
print(cnt)


from collections import Counter

n = int(input())
al = list(int(input()) for _ in range(n))
c = Counter(al)
ans = 0
for k, v in c.items():
    if v%2 != 0:
        ans += 1

print(ans)

from collections import Counter
with open(0) as f:
    N, *A = map(int, f.read().split())
ans = sum(1 for v in Counter(A).values() if v&1)
print(ans)

n = int(input())
al = []
for i in range(n):
    al.append(int(input()))

al.sort()
al.append(10**9+1)
cnt = 1
ans = 0
for j in range(n):
    if al[j] == al[j+1]:
        cnt += 1
    elif cnt%2 == 0:
        cnt = 1
    elif cnt%2 == 1:
        cnt = 1
        ans += 1
print(ans)

import collections
n=int(input())
l = [input() for i in range(n)]
c = collections.Counter(l)
ans = 0

for x,y in c.items():
    if y%2 != 0:
        ans += 1
print(ans)

n = int(input())
a = [int(input()) for _ in range(n)]
import collections
cnt = 0
b = collections.Counter(a)
for k in b:
    if b[k]%2==1:
        cnt +=1
print(cnt)

from collections import Counter


def main():
    n = int(input())
    data =Counter(int(input()) for _ in range(n))
    ans = sum(num % 2 != 0 
              for num in data.values()
              )
    print(ans)


main()

from collections import Counter
n = int(input())
a = Counter([input() for _ in range(n)])
ans = 0
for x in a.values():
    if x%2!=0: ans += 1
print(ans)

from collections import Counter

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

l=Counter(l)

cnt=0

for i in list(l.values()):
  if i%2==0:
    cnt+=1
    
print((len(l)-cnt))


N = int(input())
paper = set([])

for _ in range(N):
    a = int(input())
    if a in paper:
        paper.discard(a)
    else:
        paper.add(a)
    
print((len(paper)))


from collections import defaultdict
n = int(input())
li = []
s = set()
for val in range(n):
    i = int(input())
    if i in s:
        s.remove(i)
    else:
        s.add(i)

print(len(s))

import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
from functools import partial, reduce
from collections import Counter
#======================================================#
def f_chain(*args):
    return reduce(lambda x, f: f(x), args)
def is_odd(n):
    return n%2==1

def main():
    n = II()
    aa = [II() for _ in range(n)]
    c = Counter(aa)
    f_chain(c.values(),
            partial(filter, is_odd),
            list,
            len,
            print,
    )

def __starting_point():
    main()
__starting_point()

n=int(int(input()))
s=set()
for i in range(n):
    s^= {input()}
print(len(s))


from collections import Counter

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

L = Counter(A)

print(sum( 1 for c in L.values() if c%2 ))

n = int(input())

d = {}
for i in range(n):
    a = int(input())
    if a in d:
        d[a] ^= 1
    else:
        d[a] = 1
print(sum(d.values()))

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

paper = set()
for a in A:
    if a in paper:
        paper.remove(a)
    else:
        paper.add(a)
ans = len(paper)
print(ans)

import collections
n=int(input())
a=[int(input()) for _ in range(n)]
b=collections.Counter(a)
ans=0
for i in b.keys():
  if b[i]%2:
    ans+=1
print(ans)