stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<bits/stdc++.h>



using namespace std;



#define SCD(t) scanf("%d",&t)

#define SCLD(t) scanf("%ld",&t)

#define SCLLD(t) scanf("%lld",&t)

#define SCC(t) scanf("%c",&t)

#define SCS(t) scanf("%s",t)

#define SCF(t) scanf("%f",&t)

#define SCLF(t) scanf("%lf",&t)

#define MEM(a, b) memset(a, (b), sizeof(a))

#define FOR(i, j, k, in) for (int i=j ; i<k ; i+=in)

#define RFOR(i, j, k, in) for (int i=j ; i>=k ; i-=in)

#define REP(i, j) FOR(i, 0, j, 1)

#define RREP(i, j) RFOR(i, j, 0, 1)

#define all(cont) cont.begin(), cont.end()

#define rall(cont) cont.end(), cont.begin()

#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)

#define IN(A, B, C) assert( B <= A && A <= C)

#define MP make_pair

#define PB push_back

#define INF (int)1e9

#define EPS 1e-9

#define PI 3.1415926535897932384626433832795

#define MOD 1000000007

#define read(type) readInt<type>()

const double pi=acos(-1.0);

typedef pair<int, int> PII;

typedef vector<int> VI;

typedef vector<string> VS;

typedef vector<PII> VII;

typedef vector<VI> VVI;

typedef map<int,int> MPII;

typedef set<int> SETI;

typedef multiset<int> MSETI;

typedef long int int32;

typedef unsigned long int uint32;

typedef long long int int64;

typedef unsigned long long int  uint64;



int n,a,ret=0;

map<int,int> m;



int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL); cout.tie(NULL);

    cin>>n;

    for(int i=0;i<n;i++) {

		cin>>a;

		if(m[a]==0) {

			m[a]++;

			ret++;

		}

		else {

			m[a]--;

			ret--;

		}

	}

	cout<<ret<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.719344291372088x):
#include<stdio.h>

#include<string.h>

#include<algorithm>

using namespace std;

int a[120000];

int b[100000];

int main()

{

    int n;

    scanf("%d",&n);

    for(int i=0; i<n; i++)

        scanf("%d",&a[i]);

    sort(a,a+n);

    memset(b,0,sizeof(b));

    int s=0,j=0;

    for(int i=0; i<n; i++)

    {

        b[j]++;

        while(a[i]==a[i+1])

        {

            b[j]++;

            i++;

        }

        if(b[j]&1)

            s++;

        j++;

    }

    printf("%d\n",s);

    return 0;

}
// Slower C++ solution:
//Littleboy123 Template 1.1



#include <bits/stdc++.h>

using namespace std;



//pragmas

/*

#pragma comment(linker, "/stack:200000000")

#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#pragma GCC target ("avx2")

#pragma GCC optimization ("O3")

#pragma GCC optimization ("unroll-loops")

*/



typedef pair<int, int> ii;

typedef vector<int> vi;

typedef vector<ii> vii;

typedef long long int ll;

typedef unsigned long long int ull;

typedef long double ld;



#define FOR(a,b,c) for(ll (a)=(b);(a)<(c);++(a))

#define FORE(a,b,c) for(ll (a)=(b);(a)<=(c);++(a))

#define FORN(a,b,c) for(ll (a)=(b);(a)>(c);--(a))

#define FORNE(a,b,c) for(ll (a)=(b);(a)>=(c);--(a))

#define COUT(a) cout << (a) << '\n'

#define MEM(a,b) memset((a), (b), sizeof((a)))

#define MAX(a,b) (a) = max((a), (b))

#define MIN(a,b) (a) = min((a), (b))

#define nl '\n'

#define fi first

#define se second

#define mp make_pair

#define pb push_back

#define pi acos(-1.0)



void init(){

	ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);

}



//End of template



int main(){

	init();



	//debug

	/*

	ifstream in("input.in");

	streambuf *cinbuf = std::cin.rdbuf();

	cin.rdbuf(in.rdbuf());



	ofstream out("out.txt");

	streambuf *coutbuf = std::cout.rdbuf();

	cout.rdbuf(out.rdbuf());

	*/

	//end debug



	int n;

	cin >> n;

	int count = 0;

	int y;

	map<int, int> ada;

	FOR(i, 0, n){

		cin >> y;

		if(ada[y] == 0){

			ada[y]++;

			count++;

		}

		else{

			ada[y]--;

			count--;

		}

	}

	cout << count << nl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.733025105662904x):
#include<stdio.h>

#include<string.h>

#include<algorithm>

using namespace std;

int a[120000];

int b[100000];

int main()

{

    int n;

    scanf("%d",&n);

    for(int i=0; i<n; i++)

        scanf("%d",&a[i]);

    sort(a,a+n);

    memset(b,0,sizeof(b));

    int s=0,j=0;

    for(int i=0; i<n; i++)

    {

        b[j]++;

        while(a[i]==a[i+1])

        {

            b[j]++;

            i++;

        }

        if(b[j]&1)

            s++;

        j++;

    }

    printf("%d\n",s);

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 7.4125688879611085x):
#include<stdio.h>

#include<string.h>

#include<algorithm>

using namespace std;

int a[120000];

int b[100000];

int main()

{

    int n;

    scanf("%d",&n);

    for(int i=0; i<n; i++)

        scanf("%d",&a[i]);

    sort(a,a+n);

    memset(b,0,sizeof(b));

    int s=0,j=0;

    for(int i=0; i<n; i++)

    {

        b[j]++;

        while(a[i]==a[i+1])

        {

            b[j]++;

            i++;

        }

        if(b[j]&1)

            s++;

        j++;

    }

    printf("%d\n",s);

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

ll arr[(int)1e6+5];

int main(){

	int n;

	scanf("%d",&n);

	for(int i=0;i<n;i++){

		scanf("%lld",&arr[i]);

	}

	sort(arr,arr+n);

	ll ans=1;

	bool exist=true;

	for(int i=1;i<n;i++){

		if(arr[i]!=arr[i-1]){

			exist=true;

			ans++;

		}

		

		else{

			if(exist==1){

				ans--;

			}

			

			else{

				ans++;

			}

			exist^=1;

			

		}

	}

	

	printf("%lld\n",ans);

	

	

}

// Faster C++ solution for the same problem (measured speedup: 1.6723606581645165x):
#include<stdio.h>

#include<string.h>

#include<algorithm>

using namespace std;

int a[120000];

int b[100000];

int main()

{

    int n;

    scanf("%d",&n);

    for(int i=0; i<n; i++)

        scanf("%d",&a[i]);

    sort(a,a+n);

    memset(b,0,sizeof(b));

    int s=0,j=0;

    for(int i=0; i<n; i++)

    {

        b[j]++;

        while(a[i]==a[i+1])

        {

            b[j]++;

            i++;

        }

        if(b[j]&1)

            s++;

        j++;

    }

    printf("%d\n",s);

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

map <int, int> x;

int main() {

	int n, a, ans=0;

	scanf("%d", &n);

	while(n--) {

		scanf("%d", &a);

		x[a]++;

	}

	for(map<int,int>::iterator it = x.begin(); it!= x.end(); it++) {

		if(it->second % 2 == 1) ans++;

	}

	printf("%d\n", ans);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.6911693725215848x):
#include<stdio.h>

#include<string.h>

#include<algorithm>

using namespace std;

int a[120000];

int b[100000];

int main()

{

    int n;

    scanf("%d",&n);

    for(int i=0; i<n; i++)

        scanf("%d",&a[i]);

    sort(a,a+n);

    memset(b,0,sizeof(b));

    int s=0,j=0;

    for(int i=0; i<n; i++)

    {

        b[j]++;

        while(a[i]==a[i+1])

        {

            b[j]++;

            i++;

        }

        if(b[j]&1)

            s++;

        j++;

    }

    printf("%d\n",s);

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;



typedef long long ll;



ll a[100010];



int main() {

	

	ios_base::sync_with_stdio(false);

	cin.tie(NULL);



	ll n;

	cin>>n;



	for(ll i=0;i<n;i++) cin>>a[i];



	sort(a, a+n);



	ll ans = 0;



	ll cnt = 1;

	for(ll i=1;i<n;i++) {

		if(a[i] == a[i-1]) cnt++;

		else {

			ans += cnt % 2;

			cnt = 1;

		}

	}

	ans += cnt % 2;



	cout<<ans<<endl;

	

}

// Faster C++ solution for the same problem (measured speedup: 1.713393955125684x):
#include<stdio.h>

#include<string.h>

#include<algorithm>

using namespace std;

int a[120000];

int b[100000];

int main()

{

    int n;

    scanf("%d",&n);

    for(int i=0; i<n; i++)

        scanf("%d",&a[i]);

    sort(a,a+n);

    memset(b,0,sizeof(b));

    int s=0,j=0;

    for(int i=0; i<n; i++)

    {

        b[j]++;

        while(a[i]==a[i+1])

        {

            b[j]++;

            i++;

        }

        if(b[j]&1)

            s++;

        j++;

    }

    printf("%d\n",s);

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.3659429535546606x):
#include <iostream>

#include <cstdio>

#include <string.h>

#include <queue>

#define L 40050

#define ll long long

#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

int main()

{

    int n,h=1;

    ll a[100005];

    scanf("%d",&n);

    for(int i=0;i<n;i++)

    {

        scanf("%lld",&a[i]);

    }

    sort(a,a+n);

    int m=0;

    for(int i=0;i<n;i+=h)

    {

        h=1;

        while(a[i]==a[i+h])

            h++;

        if(h%2==1)

            m++;

    }

    printf("%d\n",m);

    return 0;



}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.309082328903741x):
#include<stdio.h>

#include<iostream>

#include<set>

#include<string.h>

using namespace std;

int main()

{

    int n;

    scanf("%d",&n);

    set<int>st;

    for(int i=0;i<n;i++)

    {

        int x;

        cin>>x;

        if(st.count(x))

        {

            st.erase(x);

        }

        else

            st.insert(x);

    }

    cout<<st.size()<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.361767301949679x):
#include<stdio.h>

#include<string.h>

#include<algorithm>

#include<iostream>

#include<map>

using namespace std;

map<int, int> mp;

int main()

{

   int n;

   cin >> n;

   for(int x, i=0; i<n; i++)

   {

       cin >> x;

       mp[x] ++;

   }

   map<int, int>::iterator it;

   int cnt = 0;

   for(it = mp.begin(); it!=mp.end(); it ++)

   {

       if(it->second % 2 == 1)

        cnt ++;

   }

   cout<<cnt<<endl;

   return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.342421011586128x):
#include<stdio.h>

#include<iostream>

#include<algorithm>

#include<string.h>

using namespace std;

int main()

{

    int n,i,a[100005],t=0;

    cin>>n;

    for(i=0; i<n; i++)

    {

        cin>>a[i];

    }

    sort(a,a+n);int c=0;

    for(i=0; i<n; i++)

    {



        if(a[i]==a[i+1])

            c++;

        else

        {

            if(c%2==0)

                t++;

                c=0;

        }

    }

    cout<<t<<" "<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.72267032387793x):
#include <cstdio>

#include <set>

using namespace std;



int main(void)

{

    int N,x;

    scanf("%d",&N);

    set<int> s;

    while(N--)

    {

        scanf("%d",&x);

        if(s.count(x)==0)

            s.insert(x);

        else

            s.erase(x);

    }

    printf("%d\n",s.size());

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.333192037245124x):
#include<iostream>

#include<set>

using namespace std;

int main()

{

    int n, temp;

    set<int> s;

    cin >> n;

    while(n--)

    {

        cin >> temp;

        if(s.count(temp) == 0)

            s.insert(temp);

        else

            s.erase(temp);

    }

    cout << s.size() << endl;

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



using VS = vector<string>;    using LL = long long;

using VI = vector<int>;       using VVI = vector<VI>;

using PII = pair<int, int>;   using PLL = pair<LL, LL>;

using VL = vector<LL>;        using VVL = vector<VL>;



#define ALL(a)  begin((a)),end((a))

#define RALL(a) (a).rbegin(), (a).rend()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define SZ(a) int((a).size())

#define SORT(c) sort(ALL((c)))

#define RSORT(c) sort(RALL((c)))

#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)

#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)

#define debug(x) cerr << #x << ": " << x << endl

const int INF = 1e9;                          const LL LINF = 1e16;

const LL MOD = 1000000007;                    const double PI = acos(-1.0);

int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };



/* -----  2018/02/14  Problem: 073_abc_c / Link: https://abc073.contest.atcoder.jp/tasks/abc073_c?lang=en  ----- */

/* ------問題------







-----問題ここまで----- */

/* -----解説等-----







----解説ここまで---- */



LL N;



LL ans = 0LL;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(false);



	cin >> N;

	map<LL, LL>Map;

	FOR(i, 0, N) {

		LL a; cin >> a;

		Map[a]++;

	}



	for (map<LL, LL>::iterator it = Map.begin(); it != Map.end(); it++) {

		if ((*it).second % 2 == 1)ans++;

	}

	cout << ans << "\n";



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.1132082952879694x):
#include<stdio.h>

#include<map>

using namespace std;

int n, a;

map<int,int> mp;



int main(){

//	freopen("c.txt","r",stdin);

	scanf("%d", &n);

	while(n--){

		scanf("%d", &a);

		if(mp.count(a)){

			mp[a]++;

		}else{

			mp[a] = 1;

		}

	}

	int ans = 0;

	for(map<int,int>::iterator it = mp.begin();it!=mp.end();it++){

		if(it->second%2 != 0){

			ans++;

		}

	}

	printf("%d\n", ans);

	return 0;

}
// Slower C++ solution:
//Littleboy123 Template 1.1



#include <bits/stdc++.h>

using namespace std;



//pragmas

/*

#pragma comment(linker, "/stack:200000000")

#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#pragma GCC target ("avx2")

#pragma GCC optimization ("O3")

#pragma GCC optimization ("unroll-loops")

*/



typedef pair<int, int> ii;

typedef vector<int> vi;

typedef vector<ii> vii;

typedef long long int ll;

typedef unsigned long long int ull;

typedef long double ld;



#define FOR(a,b,c) for(ll (a)=(b);(a)<(c);++(a))

#define FORE(a,b,c) for(ll (a)=(b);(a)<=(c);++(a))

#define FORN(a,b,c) for(ll (a)=(b);(a)>(c);--(a))

#define FORNE(a,b,c) for(ll (a)=(b);(a)>=(c);--(a))

#define COUT(a) cout << (a) << '\n'

#define MEM(a,b) memset((a), (b), sizeof((a)))

#define MAX(a,b) (a) = max((a), (b))

#define MIN(a,b) (a) = min((a), (b))

#define nl '\n'

#define fi first

#define se second

#define mp make_pair

#define pb push_back

#define pi acos(-1.0)



void init(){

	ios_base::sync_with_stdio(false);

	cin.tie(NULL);

	cout.tie(NULL);

}



//End of template



int main(){

	init();



	//debug

	/*

	ifstream in("input.in");

	streambuf *cinbuf = std::cin.rdbuf();

	cin.rdbuf(in.rdbuf());



	ofstream out("out.txt");

	streambuf *coutbuf = std::cout.rdbuf();

	cout.rdbuf(out.rdbuf());

	*/

	//end debug



	int n;

	cin >> n;

	int count = 0;

	int y;

	map<int, int> ada;

	FOR(i, 0, n){

		cin >> y;

		if(ada[y] == 0){

			ada[y]++;

			count++;

		}

		else{

			ada[y]--;

			count--;

		}

	}

	cout << count << nl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.112428943719988x):
#include<stdio.h>

#include<map>

using namespace std;

int n, a;

map<int,int> mp;



int main(){

//	freopen("c.txt","r",stdin);

	scanf("%d", &n);

	while(n--){

		scanf("%d", &a);

		if(mp.count(a)){

			mp[a]++;

		}else{

			mp[a] = 1;

		}

	}

	int ans = 0;

	for(map<int,int>::iterator it = mp.begin();it!=mp.end();it++){

		if(it->second%2 != 0){

			ans++;

		}

	}

	printf("%d\n", ans);

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.758128518358676x):
#include<stdio.h>

#include<map>

using namespace std;

int n, a;

map<int,int> mp;



int main(){

//	freopen("c.txt","r",stdin);

	scanf("%d", &n);

	while(n--){

		scanf("%d", &a);

		if(mp.count(a)){

			mp[a]++;

		}else{

			mp[a] = 1;

		}

	}

	int ans = 0;

	for(map<int,int>::iterator it = mp.begin();it!=mp.end();it++){

		if(it->second%2 != 0){

			ans++;

		}

	}

	printf("%d\n", ans);

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.367813314337281x):
//6Ã»ÓÐ£¬½øÈë;2Ã»ÓÐ£¬½øÈë£»6ÓÐ£¬³ö¡£ÓÃ¶ÓÁÐÄ£Äâ£¿ 

#include <bits/stdc++.h>

using namespace std;

map<int,bool> mp;



int main() {

	int n;cin>>n;

	int cnt = 0;

	while(n--) {

		int v;cin>>v;

		if(mp[v]==0){

			cnt++;

			mp[v]=1;

		}

		else if(mp[v] == 1) {

			cnt--;

			mp[v] = 0;

		}

	}

	cout<<cnt;

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.367070577893122x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

ll arr[200009];

int main()

{

    ll n,t,m,x,i,j,k,maxi = INT_MIN,mini = INT_MAX,flag =0,sum=0;

    vector<int>vi;

    map<ll,ll>mp;

    map<ll,ll> :: iterator it;

    cin>>n;

    while(n--)

    {

        cin>>x;

        mp[x]++;

    }

    for(it = mp.begin() ;it!=mp.end() ;it++)

    {

        if(it->second%2 ==1)

            sum++;

    }

    cout<<sum<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.330836815616871x):
#include<bits/stdc++.h>

using namespace std;

int main()

{

    map<long long int,long long int>m;

    long long int n,x,c=0;

    cin>>n;

    while(n--)

    {

        cin>>x;

        if(m[x]==0)

        {

            m[x]++;

        }

        else m[x]=0;

    }



    for( map<long long int,long long int>::iterator it=m.begin();it!=m.end();it++)

    {

        if(it->second==1) c++;

    }

    cout<<c<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.331175963583957x):
#include <bits/stdc++.h>

using namespace std;

int main()

{    long long int n,a,p;

    cin>>n;

    map<int,int>mp;

    for(int i=1;i<=n;i++)

    {

        cin>>a;

        mp[a]++;

        if(mp[a]==2){mp.erase(mp.find(a));}

    }

    p=mp.size();

    cout <<p<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

	string A[100001];

int main()

{

	long long N,total=0;

	cin>>N;

	map<string,bool>number;

	for(int i=0;i<N;i++)

	{

		cin>>A[i];

		number[A[i]]=false;

	}

	for(int i=0;i<N;i++)

	{

		if(number[A[i]]==false)

		{

			number[A[i]]=true;

			total+=1;

		}

		else

		{

			number[A[i]]=false;

			total-=1;

		}

	}

	cout<<total<<endl;

}

// Faster C++ solution for the same problem (measured speedup: 4.367235429175332x):
#include<set>

#include<iostream>

using namespace std;

int main()

{

    set<long long int>s;

    long long int n,x,i,c;

    cin>>n;

    for(i=0;i<n;i++)

    {

        cin>>x;

        if(s.find(x)!=s.end())

        {

            s.erase(x);

        }

        else

        {

            s.insert(x);

        }

    }

    long long int l=s.size();

    cout<<l<<endl;

}