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

#include <string.h>

#include <string>

#include <algorithm>

#include <map>

using namespace std;

#include <map>

#include <iostream>

int main()

{

	map<string, int> mp;

	int n;

	while (scanf("%d", &n) != EOF)

	{

		string str;

		int num = 0;

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

		{

			cin >> str;

			mp[str]++;

		}

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

		{

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

				num++;

		}

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

	}

	return 0;

}

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <string>

using namespace std;







int main()

{

//	freopen("D:\\patin.txt","r",stdin);

	int N;

	int* num = new int[1000000];

	int* data = new int[1000000];

	int sum = 0;



	scanf("%d",&N);

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

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



	}

	sort(num,num+N);

	int len = 0;

	int pre = num[0];

	while(len < N){

		int tmp = 0;

		while(num[len] == pre && len < N){

			++tmp;

			++len;

		}

		if(tmp%2)

			++sum;

		pre = num[len];	

	}

	cout << sum << endl;

	return 0;	

} 

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <set>

using namespace std;

int main(){

    set<int> st;

    int n,x;

    scanf("%d",&n);

    while(n--){

        scanf("%d",&x);

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

            st.insert(x);

        else st.erase(x);

    }

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

    return 0;

}

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<math.h>

#include<string>

#include<vector>

#include<algorithm>

#include<map>

using namespace std;

int main()

{

	long long temp;

	int n;

	scanf("%d", &n);

	map<long long, int>p;

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

	{

		scanf("%lld", &temp);

		p[temp] += 1;

	}

	int count = 0;

	for (auto it = p.begin(); it != p.end(); ++it)

	{

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

			count++;

	}

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

	system("pause");

	return 0;

}

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<cstdio>

#include<set>

using namespace std;

int main()

{

	set<int> st;

	int n,x;

	scanf("%d",&n);

	while(n--)

	{

		scanf("%d",&x);

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

			st.insert(x);

		else st.erase(x);

	}

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

	return 0;

}


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<cstring>

#include<cstdio>

#include<cmath>

#include<algorithm>

#include<string>

#include<map>



typedef long long ll;



using namespace std;

map<ll,bool> m;

int main()

{

	int n;

	cin >> n;

	int num = 0;

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

		ll k;

		cin >> k;

		if(m[k] == true){

			m[k] = false;

			num--;

		}else{

			m[k] = true;

			num++;

		}

	}

	cout << num <<endl;

	return 0;

}

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<map>



using namespace std;

typedef long long ll;



map< ll, int> num;



int main()

{

    int n;

    int a;

    int sum = 0;



    cin >> n;

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

    {

        scanf("%d", &a);

        if(num[a])

        {

            num[a]--;

            sum--;

        }

        else

        {

            num[a]++;

            sum++;

        }

    }

    cout << sum << endl;

    return 0;

}


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<set>

using namespace std;

set <int> s;

int main()

{

    int n;

    cin>>n;

    while(n--)

    {

        int x;

        cin>>x;

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

            s.erase(x);

        else

            s.insert(x);

    }

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

    return 0;

 } 


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

using namespace std;



const int M = 1e5+10;

int a[M];



int main()

{

	int m;

	cin>>m;

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

		cin>>a[i];

	sort(a,a+m);

	int cnt=0;

	a[m] = a[0]-1;

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

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

			cnt++;

		else

			i++;

	cout<<cnt<<endl;

	return 0;

}


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<set>

using namespace std;

set<int> st;

set<int>::iterator it;

int main(){

	int n;

	cin>>n;

	while(n--){

		int a;

		cin>>a;

		it=st.find(a);

		if(it!=st.end()){

			st.erase(a);

		}else{

			st.insert(a);

		} 

	}

	int ans=0;

	for(int i=0;i<st.size();i++){

		ans++;

	} 

	cout<<ans<<endl;

}


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



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

#include<iostream>

#include<queue>

#include<map>

#include<set>

#include<vector>

#include<utility>

#include<stack>

#include<algorithm>

#include<string>

#include<string.h>

#define fi first

#define se second

#define pb push_back

using namespace std;

typedef long long ll;

typedef pair<ll,ll> ii;



const int N = 1e6;



set<int> ls;



int main(){

    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);

    int n; cin >> n;

    while(n--){

        int x; cin >> x;

        if(ls.count(x))ls.erase(x);

        else ls.insert(x);

    }



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



}

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<stdio.h>

#include<string.h>

#include<set>

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;

}


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include <iostream>

#include <string.h>

#include <stdio.h>

#include <algorithm>

#define ll longlong

using namespace std;

int a[100005];

int main()

{

    int t,s=0;

  while(~scanf("%d",&t))

{

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

       {

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

       }

       sort(a,a+t);

    for(int k=0;k<t; )

      {

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

          k=k+2;

        else

         {

          s++;

          k++;

         }

      }

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

}

    return 0;

}






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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include <iostream>

#include<stdio.h>

#include<string.h>

#include<set>

using namespace std;

int main()

{

    int n;

    scanf("%d",&n);

    set<int>st;

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

    {

        int x;

        cin>>x;

        if(st.count(x))

        {

            st.erase(x);

        }

        else st.insert(x);

    }

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

    return 0;

}


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include <iostream>

#include <stdio.h>

#include <string.h>

#include <algorithm>

using namespace std;

int a[100005];

int main()

{

    int n,x=1,ans=0;///x表示一个数出现的次数，赋值1

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);///先排序

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

    {

        if(a[i]==a[i-1])///出现相同的数，x+1然后mod2

          x=(x+1)%2;

        else

        {

            ans+=x;///单独的一个数，ans+1，x重新赋值为1，进行循环

            x=1;

        }

    }

    if(x%2)///再次判断 ，若不为0，则ans+1

      ans++;

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

    return 0;

}

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<algorithm>

#include<stack>

using namespace std;

#define ll long long

ll a[100005];

int main()

{

    stack<int>s;

    int n;

    cin>>n;

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

    {

        cin>>a[i];

    }

    sort(a,a+n);

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

    {

        if(!s.empty())

        {

            if(a[i]==s.top())

            {

                s.pop();

            }

            else

                s.push(a[i]);

        }

        else

        {

           s.push(a[i]);

        }

    }

    int num=s.size();

    cout<<num<<endl;

    return 0;

}


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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



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

#include<string.h>

#include<iostream>

#include<set>

#include<algorithm>

using namespace std;

int main()

{

    std::ios::sync_with_stdio(false);

    int n;

    cin>>n;

    set<int>a;

    int x;

    while(n--)

    {

        cin>>x;

        if(a.count(x))

            a.erase(x);

        else

            a.insert(x);

    }

    printf("%d",a.size());

    return 0;

}

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

#include <string.h>

#include <algorithm>

using namespace std;

int a[100050];

int main()

{

    int n,k=0;

    scanf("%d",&n);

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

    {

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

    }

    sort(a,a+n);

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

    {

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

            i=i+2;

        else

        {

            k++;

            i++;

        }

    }

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

    return 0;



}
// Slower C++ solution:
#include<iostream>

#include<algorithm>

using namespace std;

int main(){

	int n,a[100005],ma[100005]={0},j=0,ans=0;

	cin>>n;for(int i=0;i<n;i++)cin>>a[i];sort(a,a+n);for(int i=0;i<n;i++){if(a[i]==a[i+1])ma[j]++;else{ma[j]++;j++;}}for(int l=0;l<n;l++)if(ma[l]%2==1)ans++;cout<<ans<<endl;return 0;

}

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

#include<cmath>

#include<algorithm>

//#define MODE 1

#ifdef MODE

#define DEB(X) cout<<#X<<": "<<X<<" ";

#define ARDEB(i,X) cout<<#X<<"["<<i<<"]: "<<X[i]<<" ";

#define END cout<<endl;

#else

#define DEB(X) {}

#define ARDEB(X) {}

#define END {}

#endif

using namespace std;

int main(){

	int n;

	int a[100001],co=0,ans=0;

	cin>>n;

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

	sort(a,a+n);

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

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

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

			co++;

			if(co%2==1)ans++;

			co=0;

		}

	}

	cout<<ans<<endl;

	return 0;

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



using namespace std;



int main(void)

{

	int n;

	cin >> n;

	map<int, bool> m;

	while (n--) {

		int i;

		cin >> i;

		m[i] = !m[i];

	}

	int c = 0;

	for (auto i = m.begin(); i != m.end(); ++i) {

		if (i->second) c++;

	}

	cout << c << endl;

	return 0;

}


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

#include <algorithm>

using namespace std;

int N,ptr,res;

int A[100000];

int main()

{

    scanf("%d", &N);

    for (int i=0;i<N;i++)scanf("%d",&A[i]);

    sort(A,A+N);

    while(ptr<N)

    {

        int cc=A[ptr],f=0;

        while(ptr<N&&A[ptr]==cc)f++,ptr++;

        res+=f%2;

    }

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

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

using namespace std;

int N;

vector<uint32_t> A;

int a;

int c = 0;

int main()

{

    scanf("%d", &N);

    while (N--) {

        scanf("%d", &a);

        A.push_back(a);

    }

    sort(A.begin(), A.end());

    uint32_t i = 1, prev = A[0], count = 1;

    A.push_back(0);

    while (i<A.size()) {

        if (A[i] != prev) {

            if (count % 2 == 1) {

                c++;

            }

            count = 1;

            prev = A[i];

        } else {

            count++;

        }

        i++;

    }

    cout << c << endl;

}


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

#include <algorithm>

using namespace std;

int N,ptr,res;

int A[100000];

int main()

{

    scanf("%d", &N);

    for (int i=0;i<N;i++)scanf("%d",&A[i]);

    sort(A,A+N);

    while(ptr<N)

    {

        int cc=A[ptr],f=0;

        while(ptr<N&&A[ptr]==cc)f++,ptr++;

        res+=f%2;

    }

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

}
// Slower C++ solution:
#include <cstdio>

#include <set>

using namespace std;

int N; set<long long> A; long long t;

int main() {

  scanf("%d", &N);

  for(int i = 0, c; i < N; i++) {

    scanf("%lld", &t);

    c = A.count(t);

    if(c < 1) A.insert(t);

    else if(c == 1) A.erase(t);

  }

  printf("%d", A.size());

}

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

#include <algorithm>

using namespace std;

int N, ans, A[100001];

int main() {

  scanf("%d", &N);

  for(int i = 0; i < N; i++) scanf("%d", &A[i]);

  sort(A, A+N);

  for(int i = 0, cnt = 0, pre = 0; i <= N; i++) {

    if(pre == A[i]) cnt++;

    else {ans += cnt%2; cnt = 1;}

    pre = A[i];

  }

  printf("%d", ans);

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>



using namespace std;



void count()

{

	int N;



	cin >> N;

	int data[100000];

	fill_n(data, 100000, 0);

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

	{

		cin >> data[i];

	}

	sort(data, data + N);

	int cnt = 0;

	int meyasu = 0;

	int kazoe = 0;

	while (meyasu < N)

	{

		int kazoe = 0;

		int handan = data[meyasu];

		while (meyasu < N && handan == data[meyasu])

		{

			meyasu++;

			kazoe++;

		}

		cnt += kazoe % 2;

	}

	

	cout << cnt << endl;



}





int main()

{

	count();

}

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

#include <string>

#include <algorithm>

#include <vector>

#include <cmath>

#include <map>

#include <iomanip>

#include <deque>

typedef long long ll;

#define rep(i,a,b) for(int i=a;i<b;++i)

#define rrep(i,a,b) for(int i=a;i>=b;--i)

using namespace std;

using vi = vector<int>;

using vll = vector<ll>;

ll mod = 1e9 + 7;

ll llmax = 10000000000000000000ll;

using namespace std;

using Graph = vector<vector<int>>;

Graph G;

const int AMAX = 100000;

/*int cnt_digit(ll N)

{

	int digit = 0;



	while (N > 0)

	{

		N /= 10;

		digit++;

	}

	return digit;

}







int n;

vll a;



ll solve(bool isp)

{

	ll sum = 0ll;

	ll ret = 0ll;



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

	{

		sum += a[i];

		if (isp and sum <= 0)

		{

			ret += -sum + 1;

			sum = 1ll;

		}

		if (not isp and sum >= 0)

		{

			ret += sum + 1;

			sum = -1ll;

		}

		isp ^= 1;

	}

	return ret;

}



*/





/*

 * 最大公約数計算

 */

ll gcd(ll a, ll b)

{

	if (b == 0) {

		return a;

	}

	else {

		return gcd(b, a % b);

	}

}



ll lcm(ll a, ll b)

{

	ll g = gcd(a, b);



	return a / g * b;

}



int main()

{

	cin.tie(0);

	ios::sync_with_stdio(false);

	

	int N;



	cin >> N;

	int ans = 0;

	vector <int>data(N);

	for (auto &x : data)

	{

		cin >> x;

	}

	/*for (auto &i : data)

	{

		cout << i << endl;

	}*/

	map <int, int>box;

	for (auto &x : data)

	{

		box[x]++;

	}

	

	for (auto &x : box)

	{

		if (x.second % 2 != 0)

		{

			ans++;

		}

	}

	

		cout << ans << endl;

	return 0;



}