#include <cstdio>
#include <vector>
#include <algorithm>
#include <unistd.h>
#include <cassert>

struct IO {
  static const int bufsize=1<<25;
  char ibuf[bufsize], obuf[bufsize];
  char *ip, *op;
  IO(): ip(ibuf), op(obuf) { for(int t = 0, k = 0; (k = read(STDIN_FILENO, ibuf+t, sizeof(ibuf)-t)) > 0; t+=k); }
  ~IO(){ for(int t = 0, k = 0; (k = write(STDOUT_FILENO, obuf+t, op-obuf-t)) > 0; t+=k); }
  long long scan_int(){
    long long x=0;
    bool neg=false;
    for(;*ip<'+';ip++) ;
    if(*ip=='-'){ neg=true; ip++;}
    else if(*ip=='+') ip++;
    for(;*ip>='0';ip++) x = 10*x+*ip-'0';
    if(neg) x = -x;
    return x;
  }
  void put_int(long long x, char c=0){
    static char tmp[20];
    if(x==0) *op++ = '0';
    else {
      int i;
      if(x<0){
        *op++ = '-';
        x = -x;
      }
      for(i=0; x; i++){
        tmp[i] = x % 10;
        x /= 10;
      }
      for(i--; i>=0; i--)
        *op++ = tmp[i]+'0';
    }
    if(c) *op++ = c;
  }
  void put_double(double x, char c=0){
    unsigned y;
    const int mask = (1<<24) - 1;
    put_int(x);
    *op++ = '.';
    x = x - (int) x;
    if(x < 0) x = -x;
    y = x * (1<<24);

    for(int i=0;i<7;i++){
      y *= 10;
      *op++ = '0' + (y>>24);
      y &= mask;
    }
    if(c) *op++ = c;
  }
  inline char scan_char(){ return *ip++; }
  inline void put_char(char c){ *op++ = c; }
  inline char *scan_string(){ char *s = ip; while(*ip!='\n'&&*ip!=' ') ip++; *ip++='\0'; return s;}
  inline void put_string(const char *s, char c=0){ while(*s) *op++=*s++; if(c) *op++=c;}
} io;

using u8 = unsigned char;
using u32 = unsigned int;
using u64 = unsigned long long int;

template <typename KeyT, typename ValT, typename Hash, ValT Z = ValT()>
class hash_map {
  int n;
  u32 sz;
  std::vector<u64> s;
  std::vector<std::pair<KeyT, ValT> > v;
  Hash hash;
  static constexpr ValT nf = Z;

  static bool test(u32 i, const std::vector<u64> &t) { return !!(t[i/64] & (1ULL << (i % 64))); }
  static void set(u32 i, std::vector<u64> &t) { t[i/64] |= 1ULL << (i % 64); }

  u32 find(const KeyT &a) const {
    u32 ind = hash(a, n);
    u32 i;
    for(i = ind; i < ind + (1 << n); ++i){
      u32 j = i & ((1 << n) - 1);
      if(!test(j, s)) return j;
      if(v[j].first == a) return j;
    }
    return -1;
  }

  void reallocate(){
    ++n;
    std::vector<u64> t(1<<(n-6));
    std::vector<std::pair<KeyT, ValT> > w(1<<n);
    for(u32 i = 0; i < v.size(); ++i){
      if(!test(i, s)) continue;
      u32 j = hash(v[i].first, n);
      while(test(j, t)) ++j, j &= (1 << n) - 1;
      set(j, t);
      w[j] = std::move(v[i]);
    }

    s = std::move(t);
    v = std::move(w);
  }

  public:
  hash_map(): n(10), sz(0), s(1<<(n-6)), v(1<<n)  {
  }

  ValT &operator[](const KeyT &a){
    u32 i = find(a);
    if(v[i].first == a) return v[i].second;

    ++sz;
    if(sz + sz/2 >= (1U<<n)){
      reallocate();
      i = find(a);
    }
    set(i, s);
    v[i].first = a;
    return v[i].second = Z;
  }

  const ValT &at(const KeyT &a) const {
    u32 i = find(a);
    return test(i, s) ? v[i].second : nf;
  }
 
  u32 size() const { return sz; }
};

struct hash_u32 {
  u32 operator()(u32 a, int n) const {
    static constexpr u32 r = 1252263111U;
    return a * r >> (32 - n);
  }
};


int main(){
  int n = io.scan_int();
  hash_map<u32, u32, hash_u32> h;
  u32 count = 0;
  for(int i = 0; i < n; i++){
    u32 a = io.scan_int();
    if((++h[a]) & 1) ++count;
    else --count;
  }
  io.put_int(count, '\n');
  return 0;
}


Measured memory_bytes: 5360