AtCoder Beginner Contest 073 - Write and Erase

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: EASY

Starter code:

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


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)


ss = set()
for _ in range(int(input())):
	s = input()
	ss.remove(s) if s in ss else ss.add(s)
print(len(ss))


from collections import *
(n, *a) = map(int, open(0).read().split())
print(sum((v % 2 for v in Counter(a).values())))


(N, *A) = map(int, open(0))
import collections
C = collections.Counter(A)
print(sum((v % 2 > 0 for v in C.values())))


N = int(input())
s = set([])
for i in range(N):
	t = input()
	if t not in s:
		s.add(t)
	else:
		s.remove(t)
print(len(s))


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)


n = int(input())
di = {}
for x in range(n):
	i = int(input())
	if i in di.keys():
		di.pop(i)
	else:
		di[i] = i
print(len(di))


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


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


from collections import Counter
n = int(input())
a = [int(input()) for i in range(n)]
print(sum(map(lambda x: x % 2, Counter(a).values())))


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


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


N = int(input())
d = {}
for i in range(N):
	a = int(input())
	d[a] = 1 - d.get(a, 0)
print(sum(d.values()))


N = int(input())
A = [int(input()) for _ in range(N)]
s = set()
for a in A:
	s ^= set([a])
print(len(s))


N = int(input())
d = dict()
for _ in range(N):
	a = int(input())
	d[a] = d.get(a, 0) ^ 1
print(sum(d.values()))


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))


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()))


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 = int(input())
	if a not in A:
		A[a] = 1
	else:
		A.pop(a)
print(len(A))


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 = 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(ans)


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


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)


N = int(input())
A = [int(input()) for i in range(N)]
dic = {}
for i in A:
	dic[i] = dic.get(i, 0) ^ 1
print(list(dic.values()).count(1))


d = dict()
for i in range(int(input())):
	elem = int(input())
	if elem in d:
		del d[elem]
	else:
		d[elem] = i
print(len(d))


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


n = int(input())
a = [int(input()) for _ in range(n)]
ans = set()
for i in a:
	ans ^= {i}
print(len(ans))


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)


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)


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


(n, c) = (int(input()), {})
for i in range(n):
	a = int(input())
	if a in c:
		del c[a]
	else:
		c[a] = 1
print(len(c))


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)


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()


(n, *a) = map(int, open(0).read().split())
s = set()
for i in a:
	s ^= {i}
print(len(s))


n = int(input())
d = {}
for _ in range(n):
	a = int(input())
	if a in d:
		del d[a]
	else:
		d[a] = 1
print(len(d))


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)


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()


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())
paper = set([])
for _ in range(N):
	a = int(input())
	if a in paper:
		paper.discard(a)
	else:
		paper.add(a)
print(len(paper))


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


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


from math import gcd
from itertools import combinations, permutations, accumulate, product
from collections import deque, defaultdict, Counter
import decimal
import re
import math
import bisect
import heapq
import sys
sys.setrecursionlimit(10000000)
mod = 10 ** 9 + 7
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 = {}
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)


from collections import Counter
n = int(input())
c = Counter((int(input()) for _ in range(n)))
print(sum((v & 1 for v in c.values())))


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


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


N = int(input())
A = [int(input()) for _ in range(N)]
memo = dict()
for a in A:
	memo[a] = not memo.get(a, False)
print(sum(memo.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)


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


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


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


from collections import Counter as C
n = int(input())
a = C([input() for _ in range(n)])
print(sum(map(lambda v: v % 2, a.values())))


d = {}
for _ in [0] * int(input()):
	i = input()
	d[i] = d.get(i, 0) ^ 1
print(sum(d.values()))


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)


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


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


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


from collections import Counter
(N, *A) = map(int, open(0).read().split())
print(sum([1 for (v, c) in Counter(A).most_common() if c % 2 == 1]))


n = int(input())
s = set()
for _ in range(n):
	s ^= {input()}
print(len(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()))


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()


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


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


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


import sys
(n, *A) = map(int, sys.stdin)
B = set()
for a in A:
	B ^= {a}
print(len(B))


N = int(input())
Paper = {}
for _ in range(N):
	a = int(input())
	if a in Paper:
		del Paper[a]
	else:
		Paper[a] = 1
print(len(Paper.keys()))


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


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)


N = int(input())
ans = {}
for i in range(N):
	ai = int(input())
	if ans.get(ai):
		ans.pop(ai)
	else:
		ans[ai] = 1
print(len(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)


from collections import Counter as co
n = int(input())
l = [int(input()) for _ in range(n)]
print(len([1 for (a, d) in co(l).items() if d % 2]))


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


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


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


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))


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


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())])

def main():

	def iterate_tokens():
		for line in sys.stdin:
			for word in line.split():
				yield word
	tokens = iterate_tokens()
	N = int(next(tokens))
	A = [int(next(tokens)) for _ in range(N)]
	print(solve(N, A))

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

def __starting_point():
	main()
__starting_point()


d = {}
for i in range(int(input())):
	i = int(input())
	if i not in d.keys():
		d[i] = 1
	else:
		del d[i]
print(len(d))


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)


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)


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)


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))


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)


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


from collections import *
N = int(input())
C = Counter([int(input()) for n in range(N)])
print(sum((v % 2 == 1 for v in C.values())))


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())
S = set()
for i in range(n):
	S ^= set([input()])
print(len(S))


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
		elif hoge == 0:
			ans += 1
	elif foo == a[i]:
		hoge = 1 - hoge
	else:
		if hoge == 1:
			ans += 1
		foo = a[i]
		hoge = 1
print(ans)


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


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)


N = int(input())
A = {}
for _ in range(N):
	a = int(input())
	if a in A:
		A.pop(a)
	else:
		A[a] = 1
print(len(A))


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)


import collections
N = int(input())
A = collections.Counter([int(input()) for _ in range(N)])
print(sum(map(lambda x: x % 2 == 1, A.values())))


N = int(input())
A = [int(input()) for i in range(N)]
from collections import Counter
print(sum((c % 2 for (x, c) in Counter(A).items())))


(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())
l = [int(input()) for i in range(n)]
from collections import Counter
c = Counter(l)
s = 0
for i in c:
	s += c[i] & 1
print(s)


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()


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)


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


from collections import Counter as C
n = int(input())
a = C([input() for _ in range(n)])
print(sum([1 for v in a.values() if v % 2]))


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))


h = {}
N = int(input())
for i in range(N):
	a = int(input())
	if a in h:
		h.pop(a)
	else:
		h[a] = 1
print(len(h))


n = int(input())
d = {}
for _ in [0] * n:
	v = int(input())
	d[v] = (d.get(v, 0) + 1) % 2
print(sum(d.values()))


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)


import sys
N = int(input())
A = set()
for i in sys.stdin:
	A ^= {i}
print(len(A))


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))


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


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())
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)


from collections import *
(_, *l) = map(int, open(0).read().split())
c = Counter(l)
a = 0
for i in c.values():
	a += i % 2
print(a)


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


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()))


from collections import defaultdict
note = defaultdict(int)
for _ in range(int(input())):
	note[input()] ^= 1
print(sum(note.values()))


A = {}
for _ in range(int(input())):
	a = input()
	A[a] = A.get(a, 0) + 1
print(len(list(filter(lambda x: x % 2 != 0, A.values()))))


d = set()
for i in [0] * int(input()):
	d ^= {input()}
print(len(d))


x = int(input())
a = []
B = {-1}
for i in range(x):
	Y = int(input())
	if Y not in B:
		B.add(Y)
	else:
		B.discard(Y)
print(len(B) - 1)


from collections import Counter
print(len([1 for i in Counter([int(input()) for i in range(int(input()))]).values() if i % 2 != 0]))


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
for key in d.keys():
	if d[key] % 2 == 1:
		ans += 1
		d[key] = 0
print(ans)


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)


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()))


from collections import Counter
N = int(input())
c = Counter([input() for _ in range(N)])
print(len([1 for k in c.keys() if c[k] % 2 == 1]))


(_, *a) = map(int, open(0))
from collections import *
print(sum(map(lambda k: k % 2, Counter(a).values())))


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())
s = set()
for i in range(N):
	A = int(input())
	if A in s:
		s.discard(A)
	else:
		s.add(A)
print(len(s))


n = int(input())
from collections import defaultdict
a = defaultdict(int)
for i in range(n):
	a[int(input())] ^= 1
print(sum(a.values()))


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))


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)


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())
s = set([])
for i in range(n):
	x = int(input())
	if not x in s:
		s.add(x)
	else:
		s.remove(x)
print(len(s))


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)


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())
A = set()
for i in range(n):
	A ^= {int(input())}
print(len(A))


import sys

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(input())
se = set()
for _ in range(n):
	se ^= {int(input())}
ans = len(se)
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)


n = int(input())
a = [input() for _ in range(n)]
l = {}
for i in a:
	if i in l:
		del l[i]
	else:
		l[i] = 0
print(len(l))


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, *A) = map(int, open(0).read().split())
d = dict()
for a in A:
	d[a] = d.get(a, 0) ^ 1
print(sum(d.values()))


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


from collections import Counter
n = int(input())
a = [int(input()) for i in range(n)]
print(sum((j % 2 for (i, j) in Counter(a).items())))


import collections
n = int(input())
aa = [int(input()) for a in range(n)]
caa = collections.Counter(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 = [int(input()) for _ in [0] * n]
s = set()
for x in a:
	s ^= {x}
print(len(s))


from sys import stdin, stdout

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()


N = int(input())
A = {}
for i in range(N):
	a = input()
	A.setdefault(a, 0)
	A[a] = 1 - A[a]
print(sum(A.values()))


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)


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


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))


s = {0}
for _ in [0] * int(input()):
	t = int(input())
	if t in s:
		s -= {t}
	else:
		s |= {t}
print(len(s) - 1)


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


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)


import collections as c
print(sum([1 for i in c.Counter([int(input()) for _ in range(int(input()))]).values() if i % 2 != 0]))


(_, a, *s) = open(0)
a = {a}
for i in s:
	a ^= {i}
print(len(a))


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


import sys
f = sys.stdin.readline
l = [f() for _ in range(int(f()))]
from collections import *
c = Counter(l)
print(sum((v % 2 for v in c.values())))


(N, *A) = open(0)
S = set()
for a in A:
	S ^= {int(a)}
print(len(S))


numbers = {}
for _ in [0] * int(input()):
	A = int(input())
	numbers[A] = numbers.get(A, 0) ^ 1
print(sum(numbers.values()))


A = {}
n = int(input())
for _ in range(n):
	a = int(input())
	A[a] = not A.setdefault(a, False)
print(sum(A.values()))


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)


b = set()
(n, *a) = map(int, open(0).read().split())
for i in a:
	if i not in b:
		b.add(i)
	else:
		b.remove(i)
print(len(b))


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


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)


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)


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)


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)


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


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)


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)


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)


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)


n = int(input())
d = {}
for _ in [0] * n:
	k = int(input())
	if k in d:
		d[k] = 1 - d[k]
	else:
		d[k] = 1
print(sum(d.values()))


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())
al = list((int(input()) for _ in range(n)))
s = set()
for a in al:
	s ^= {a}
print(len(s))


(N, *A) = open(0)
s = set()
for a in A:
	s ^= {int(a)}
print(len(s))


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)


from collections import Counter
n = int(input())
a = Counter([int(input()) for i in range(n)])
print(sum([v % 2 == 1 for v in a.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())
w = set()
for _ in range(N):
	n = int(input())
	w.add(n) if not n in w else w.remove(n)
print(len(w))


N = int(input())
A = [int(input()) for _ in range(N)]
d = {}
for i in A:
	d[i] = 0
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 = Counter([input() for i in range(n)])
print(len([x for x in a.values() if x % 2 == 1]))


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 sys
mod = 10 ** 9 + 7
inf = float('inf')
from math import sqrt, ceil
from collections import deque, Counter, defaultdict
input = lambda : sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP, Decimal
from functools import lru_cache
from bisect import bisect_left as bileft, bisect_right as biright
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]))


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)


import collections
(N, *A) = map(int, open(0).read().split())
B = collections.Counter(A)
print(len([v for (k, v) in B.items() if v % 2]))


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


import sys
input = sys.stdin.readline
n = int(input())
s = set()
for i in range(n):
	s ^= {input().strip()}
print(len(s))


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())
D = {}
for _ in range(N):
	A = int(input())
	D[A] = not D.get(A, False)
print(sum(D.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())
l = set()
for i in range(n):
	tmp = int(input())
	l.remove(tmp) if tmp in l else l.add(tmp)
print(len(l))


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()


N = int(input())
A = [int(input()) for _ in range(N)]
m = {}
for a in A:
	if not a in m:
		m[a] = 1
	else:
		del m[a]
print(len(m))


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())
d = {}
for _ in [0] * n:
	a = int(input())
	d[a] = d.get(a, 0) + 1
print(sum((i % 2 for i in d.values())))


from collections import *
(_, *a) = map(int, open(0))
print(sum((i % 2 for i in Counter(a).values())))


N = int(input())
dic = {}
for _ in range(N):
	A = input()
	if A in dic:
		del dic[A]
	else:
		dic[A] = 0
print(len(dic))


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


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


from collections import *
(N, *A) = map(int, open(0).read().split())
print(sum([i & 1 for i in Counter(A).values()]))


n = int(input())
a = [int(input()) for _ in range(n)]
a_set = set()
for a_i in a:
	a_set ^= {a_i}
print(len(a_set))


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))


l = [input() for _ in range(int(input()))]
from collections import *
c = Counter(l)
print(sum((v % 2 for v in c.values())))


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)


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))


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)


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 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 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 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()))))