jiahuimbzuai/CoQuIR huggingface dataset:
//  [typescript]
const main = (input) => {
  const lines = input.trim().split("\n")
  const [N, K] = lines[0].split(" ").map(str => parseInt(str))
  let H = lines[1].split(" ").map(str => parseInt(str))
  H.sort()

  if(K > 0) { H.splice(-K) }

  const sum = (arr: number[]) => {
    if(arr.length !== 0) {
      return arr.reduce((a:number , b: number) => a + b)
    }
    return 0
  }
  
  console.log(sum(H))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input) => {
  const lines = input.trim().split("\n")
  const [N, K] = lines[0].split(" ").map(str => parseInt(str))
  let H = lines[1].split(" ").map(str => parseInt(str))
  H.sort()

  if(K > 0) { H.splice(-K) }

  const sum = (arr) =>  arr.reduce((a , b) => a + b, 0)
  
  console.log(sum(H))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input) => {
  const lines = input.trim().split("\n")
  const [N, K] = lines[0].split(" ").map(str => parseInt(str))
  let H = lines[1].split(" ").map(str => parseInt(str))
  H.sort()

  if(K > 0) { H.splice(-K) }

  const sum = (arr) =>  arr.reduce((a , b) => a + b)
  
  console.log(sum(H))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
n,k = map(int,input().split())
print(sum([1 for i in map(int,input().split()) if i >= k]))
//  [python]
def main():
    n, k = map(int, input().split())
    hs = map(int, input().split())
    print(len([h for h in hs if h >= k]))


main()
//  [python]
def calculate(people_num, limit, height_array):
    permission = [height for height in height_array if height >= limit]
    return len(permission)
 
if __name__ == "__main__":
    people_num, limit = map(int, input().split())
    height_array = map(int, input().split())
    result_num = calculate(people_num, limit, height_array)
    print(result_num)
//  [python]
n,k=map(int,input().split())
h=0
t=0
for i in range(1,n+1):
    h=int(input())
    if h>=k:
        t=t+1
print(t)
//  [python]
import java.util.*;
import java.io.*;
import java.lang.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int k = sc.nextInt();

        int ans = 0;
        
        for (int i = 0; i<n; i++){
            if (sc.nextInt() >= k)
                ans++;
        }
        System.out.println(ans);
    }
}
//  [java]
import java.util.Scanner;
import java.util.Arrays;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N =  sc.nextInt();
        int K =  sc.nextInt();
        System.out.println(N);
        System.out.println(K);
        int[] h = new int[N];
        for(int i = 0; i < N; i++){
            h[i] = sc.nextInt();
        }

        System.out.println(Arrays.stream(h).filter(x -> x >= K).count());

    }
}
//  [java]
import java.io.*;
import java.lang.*;

public class Main {
 	public static void main (String[] args) {
     	Scanner sc = new Scanner(System.in);
      	int n = sc.nextInt();
      	int k = sc.nextInt(); int count = 0;
      	for (int i = 0; i<n; i++) {
         	int x = sc.nextInt();
          	if (x>=k)
              count++;
        }
      System.out.println(count);
      
    }
}
//  [java]
import java.io.*;
import java.util.*;

public class Main {
 	public static void main (String[] args) { 
     Scanner sc = new Scanner(System.in);
      int n = sc.nextInt();
      int k = sc.nextInt();
      int count = 0;
      for (int i = 0; i < n; i++) {
       int x = sc.nextInt();
        if (x<=k)
          count++;
      }
      System.out.println(count);
    }
}
//  [cpp]
//#include<bits/stdc++.h>
#include<cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please

const int cm = 1 << 19;
char cn[cm], * ci = cn;
inline int getint() {
	char C = *ci++;
	int A = C - '0';
	while ((C = *ci++) >= '0') A = A * 10 + C - '0';
	return A;
}

int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);

	fread(cn, 1, cm, stdin);

	int N = getint(), K = getint();
	int kotae = 0;
	rep(i, N) if (getint() >= K) kotae++;
	printf("%d", kotae);

	Would you please return 0;
}
//  [cpp]
#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
inline void rd(int &x){
  int k;
  int m=0;
  x=0;
  for(;;){
    k = getchar_unlocked();
    if(k=='-'){
      m=1;
      break;
    }
    if('0'<=k&&k<='9'){
      x=k-'0';
      break;
    }
  }
  for(;;){
    k = getchar_unlocked();
    if(k<'0'||k>'9'){
      break;
    }
    x=x*10+k-'0';
  }
  if(m){
    x=-x;
  }
}
inline int rd_int(void){
  int x;
  rd(x);
  return x;
}
inline void wt_L(char a){
  putchar_unlocked(a);
}
inline void wt_L(int x){
  int s=0;
  int m=0;
  char f[10];
  if(x<0){
    m=1;
    x=-x;
  }
  while(x){
    f[s++]=x%10;
    x/=10;
  }
  if(!s){
    f[s++]=0;
  }
  if(m){
    putchar_unlocked('-');
  }
  while(s--){
    putchar_unlocked(f[s]+'0');
  }
}
int N;
int K;
int main(){
  int i;
  int res = 0;
  rd(N);
  rd(K);
  for(i=(0);i<(N);i++){
    if(K <= rd_int()){
      res++;
    }
  }
  wt_L(res);
  wt_L('\n');
  return 0;
}
// cLay varsion 20190929-1

// --- original code ---
// int N, K;
// {
//   int res = 0;
//   rd(N,K);
//   rep(i,N) if(K <= rd_int()) res++;
//   wt(res);
// }
//  [cpp]
#include <bits/stdc++.h>
    #include <math.h>
 
    using namespace std;
    typedef long long ll;
    typedef unsigned long long ull;
    # define M_PI  3.14159265358979323846
 
 
    const int M=1e9+7;
    long long mod(long long x){
        return ((x%M + M)%M);
    }
    long long add(long long a, long long b){
        return mod(mod(a)+mod(b));
    }
    long long mul(long long a, long long b){
        return mod(mod(a)*mod(b));
    }
 
    ll modPow(ll a, ll b){
        if(b==0)
            return 1LL;
        if(b==1)
            return a%M;
        ll res=1;
        while(b){
            if(b%2==1)
                res=mul(res,a);
            a=mul(a,a);
            b=b/2;
        }
        return res;
    }
 
    void solve (){
        int n,k;
        cin>>n>>k;
        int total=0;
        for(int i=0;i<n;i++){
            int x;
            cin>>x;
            if(x<=k)
                total++;
        }
        cout<<total;
    }
    int main(){
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
        cout<<fixed;
        cout<<setprecision(10);
//        freopen("timber_input.txt", "r", stdin);
//        freopen("timber_output.txt", "w", stdout);
        int t=1;
        // cin>>t;
        for(int i=1;i<=t;i++){
//            cout<<"Case #"<<i<<": ";
            solve();
        }
        return 0;
    }
//  [cpp]
#include <bits/stdc++.h>
#define ll long long
using namespace std;
 
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int n, k;
	int d=0;
	int a[10000];
	cin >> n >> k;
	for(int i=0; i < n; i++)
		cin >> a[i];
		
	for(int i=0; i < n; i++)
		if(a[i] >= k)
			d++;
	cout << d;
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
 
int main() {
  int n, k;
  cin >> n >> k;
  vector<int> h(n);
  rep(i,n) cin >> h[i];
  int ans = 0;
  rep(i,n) {
    if (h[i] >= k) ans++;
  }
  cout << ans << endl;
//  [c]
// ABC-142 B:
// 2019.9.28 bal4u
// Template for Online Contest

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef long long ll;

#define gc() getchar()
#define pc(c) putchar(c)

int in() {  // 整数の入力
	int n = 0, c = gc();
	if (c == '-') {	c = gc();
		do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
		return -n;
	}
	do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
	return n;
}

ll inL() {  // long long 整数の入力
	ll n = 0; int c = gc();
	if (c == '-') {	c = gc();
		do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
		return -n;
	}
	do n = 10*n + (c & 0xf), c = gc(); while (c >= '0');
	return n;
}

void out(int n) { // 整数の表示
	int i; char b[30];
	if (!n) pc('0');
	else {
		if (n < 0) pc('-'), n = -n;
		i = 0; while (n) b[i++] = n % 10 + '0', n /= 10;
		while (i--) pc(b[i]);
	}
	pc('\n');
}

void outL(ll n) { // 整数の表示
	int i; char b[30];
	if (!n) pc('0');
	else {
		if (n < 0) pc('-'), n = -n;
		i = 0; while (n) b[i++] = n % 10 + '0', n /= 10;
		while (i--) pc(b[i]);
	}
	pc('\n');
}

int ins(char *s) { // 文字列の入力
	char *p = s--;
	do *++s = gc();
	while (*s > ' ');
	*s = 0;
	return s - p;
}

void outs(char *s) {  // 文字列の表示
	while (*s) pc(*s++);
}

#define MIN(a,b)  ((a)<=(b)?(a):(b))
#define MAX(a,b)  ((a)>=(b)?(a):(b))
#define ABS(a)    ((a)>=0?(a):-(a))
inline static int chmax(int *a, int b) { if (*a < b) *a = b; }
inline static ll  chmaxL(ll *a, int b) { if (*a < b) *a = b; }
inline static int chmin(int *a, int b) { if (*a > b) *a = b; }
inline static ll  chminL(ll *a, int b) { if (*a > b) *a = b; }

int cmp_int(const void *u, const void *v) { return *(int *)u - *(int *)v; }

int main()
{
	int i, N, K;
	int ans;
	
	N = in(), K = in();
	ans = 0; while (N--) if (in() >= K) ans++;
	printf("%d\n", ans);
	return 0;
}
//  [c]
//Twitter@KonoLv1 2020年春からエンジニア見習いデビュー！
 
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
 
int main(void){
    int i,j;            //  ループ文に使用
    int x,y,z;
    int count1,count2,count;   //  カウント用に使用
    int boxa[1024] = {};
    int boxb[1024] = {};
    char s[200001] = {};        //  文字列
    char s2[200001] = {};        //  文字列
    int a,b,c,h,w;
    int n,k;
    a = b = c = i = 0;
    int mode = 0;
    count = count1 = count2 = 0;
 
    //  入力処理
    
    scanf("%d %d",&n,&k);
    for (i = 0; i < n; i++){
        scanf("%d",&x);
        if (x >= k){
            count++;
        }
    }
 
    //  計算処理
    
 
 
    //  出力処理
 
    printf("%d",count);

 
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

int main() {

    int n, k,h;
    scanf("%d %d", &n,&k);

    int cnt=0;
    
    for(int i=0;i<n;i++){
        scanf("%d",&h);
        if(h>=k){
            cnt++;
        }
    }
    printf("%d",cnt);

    return 0;

}
//  [c]
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1LL<<60;

ll GCD(ll x,ll y){
    if(y == 0) return x;
    else return GCD(y,x%y);
}

ll LCM(ll a,ll b){
    return a / GCD(a,b) * b;
}

const int MOD = 1000000007;



int main() {
    int n,k; cin >> n >> k;
    int ans = 0;
    for(int i = 0;i < n;i++){
        int x; cin >> x;
        if(x >= k) ans++;
    }
    cout << ans;
}
//  [c]
#include <stdio.h>
int main(void){
    int k, i, cnt;
    long n;
    int h[100000];
    
    scanf("%ld %d", &n, &k);
    for(i = 0; i < n;  i++){
        scanf("%d", &h[i]);
    }
    cnt = 0;
    for(i = 0; i < n; i++){
        if(h[i] >= k){
            ans = ans + 1;
        }
    }
    printf("%d", ans);
}
//  [c]
#include <stdio.h>
int main(void){
    int k, i, cnt;
    long n;
    int h[10000];
    cnt = 0;
    
    scanf("%ld %d", &n, &k);
    
    for(i = 0; i < n; i++){
        scanf("%d", &h[i]);
    }
    
    for(i = 0; i < n; i++){
        if(h[i] >= k){
            cnt = cnt + 1;
        }
    }
    
    printf("%d", cnt);
}
//  [javascript]
function Main(input) {
  input = input.split('\n');
  tmp = input[0].split(' ');
  heights = input[1].split(' ');
  numFriends = parseInt(tmp[0], 10);
  minHeight = parseInt(tmp[1], 10); 
  var count = 0;

//console.log('data heights: ' + heights);
//console.log('data numFriends: ' + numFriends);
//console.log('data minHeight: ' + minHeight);
  for(var i = 0; i < numFriends; i++) {
    if(parseInt(heights[i], 10) >= minHeight) {
      count++;
    }
  }
  console.log(count);
}
Main(require('fs').readFileSync('/dev/stdin', 'utf-8'));
//  [javascript]
function main(input){
  var num;
  var inputNK;
  var inputH;
  var inputN;
  var inputK;
  input = input.split('\n');
  inputNK = input[0].split(' ');
  inputH =  input[1].split(' ');
  inputN = parseInt(inputNK[0]);
  inputK = parseInt(inputNK[1]);
  num = 0;
  for(var i=0 ; i<inputN; i++){
    if(parseInt(inputH[i]) >= inputK){
      num++;
    }
  }
  console.log(num);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {

	input = input.split("\n");
  	data = input[0].split(" ");
  	each_data = input[1].split(" ");

	var member_cnt = parseInt(data[0], 10);
	var max_hight = parseInt(data[1],10);
  
  	var parce_cnt = 0;
  
  	for(var cnt=0; cnt<member_cnt; cnt++){
      	if(max_hight <= parseInt(each_data[cnt])){
          	parce_cnt++;
        }
    }
  
	console.log(parce_cnt);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'

const main = (INPUT) => {
  const input = INPUT.split('\n')
  const [N, K] = input[0].split(' ')
  const h = input[1].split(' ')
  let ans = 0
  for (let i = 0; i < h.length; i++) {
    if (h[i] >= K) {
      ans++
    }
  }
  console.log(ans)
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function read() {
  return require('fs')
    .readFileSync('/dev/stdin', 'utf8')
    .trim()
    .replace(/\n/g, ' ')
    .split(' ');
}

const [, K, ...H] = read().map(token => +token);
console.log(H.filter(h => h >= K).length);
//  [javascript]
Main = input => {
  input = input.split("\n");
  const tmp = input[0].split(" ");
  const n = tmp[0];
  const k = tmp[1];
  const h = input[1].split(" ");
  
  var cnt = 0;
  h.forEach(ht => {
    if (ht >= k) {
      cnt++;
    }
  });
  
  console.log(cnt);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var sc = bufio.NewScanner(os.Stdin)

func inputAsInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func inputAsString() string {
	sc.Scan()
	return sc.Text()
}

func inputIntSlice(n int) []int {
	strSlice := strings.Split(inputAsString(), " ")
	arr := make([]int, n)
	for i, a := range strSlice {
		arr[i] = mustAtoi(a)

	}
	return arr
}

func mustAtoi(s string) int {
	i, err := strconv.Atoi(s)
	if err != nil {
		panic(err)
	}
	return i
}

//
//type sortable [][]int
//
//func (s sortable) Len() int { return len(s) }
//
//func (s sortable) Less(i, j int) bool { return s[i][0] < s[j][0] }
//
//func (s sortable) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

func main() {
	sc.Buffer([]byte{}, 100000000)

	var n, k int
	fmt.Scan(&n, &k)
	his := inputIntSlice(n)

	count := 0
	for _, a := range his {
		if a >= k {
			count++
		}
	}
	fmt.Println(count)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	//	"strings"
)

func main() {
	sc := NewScanner()

	n := sc.NextInt()
	k := sc.NextInt()

	ans := 0
	for i := 0; i < n; i++ {
		tmp := sc.NextInt()
		if tmp >= k {
			ans++
		}
	}

	fmt.Printf("%v\n", ans)

}

type Scanner struct {
	r   *bufio.Reader
	buf []byte
	p   int
}

func NewScanner() *Scanner {
	rdr := bufio.NewReaderSize(os.Stdin, 1000)
	return &Scanner{r: rdr}
}
func (s *Scanner) Next() string {
	s.pre()
	start := s.p
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			break
		}
	}
	result := string(s.buf[start:s.p])
	s.p++
	return result
}
func (s *Scanner) NextLine() string {
	s.pre()
	start := s.p
	s.p = len(s.buf)
	return string(s.buf[start:])
}
func (s *Scanner) NextInt() int {
	v, _ := strconv.Atoi(s.Next())
	return v
}

func (s *Scanner) NextIntArray() []int {
	s.pre()
	start := s.p
	result := []int{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			result = append(result, v)
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	result = append(result, v)

	return result
}

func (s *Scanner) NextMap() map[int]bool {
	s.pre()
	start := s.p
	mp := map[int]bool{}
	for ; s.p < len(s.buf); s.p++ {
		if s.buf[s.p] == ' ' {
			v, _ := strconv.Atoi(string(s.buf[start:s.p]))
			mp[v] = true
			start = s.p + 1
		}
	}
	v, _ := strconv.Atoi(string(s.buf[start:s.p]))
	mp[v] = true

	return mp
}

func (s *Scanner) pre() {
	if s.p >= len(s.buf) {
		s.readLine()
		s.p = 0
	}
}
func (s *Scanner) readLine() {
	s.buf = make([]byte, 0)
	for {
		l, p, e := s.r.ReadLine()
		if e != nil {
			panic(e)
		}
		s.buf = append(s.buf, l...)
		if !p {
			break
		}
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    const maxCapacity = 512*1024  
    buf := make([]byte, maxCapacity)
    scanner.Buffer(buf, maxCapacity)
  
	var n, k, h, cnt int
	scanner.Scan()
	fmt.Sscan(scanner.Text(), &n, &k)

	scanner.Scan()
	for _, v := range strings.Split(scanner.Text(), " ") {
        h, _ = strconv.Atoi(v)
		if h >= k {
			cnt++
		}
	}
	fmt.Println(cnt)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	var n, k, h, cnt int
	scanner.Scan()
	fmt.Sscan(scanner.Text(), &n, &k)

	scanner.Scan()
	for _, v := range strings.Split(scanner.Text(), " ") {
		h, _ = strconv.Atoi(v)
		if h >= k {
			cnt++
		}
	}
	fmt.Println(cnt)
}
//  [go]
package main
import(
  "fmt"
  "bufio"
  "os"
  "strconv"
)
var sc=bufio.NewScanner(os.Stdin)
func nextInt() int{
  sc.Scan()
  i, e :=strconv.Atoi(sc.Text())
  if e!=nil{
    panic(e)
  }
  return i
}
func main(){
  var i, j int
  ans:=0
  sc.Split(bufio.ScanWords)
  n:=nextInt()
  a:=make([]int, n)
  for i=0;i<n;i++{
    a[i]=nextInt()
  }
  for i=0;i<n;i++{
    if a[i]>=j{
      ans++
    }
  }
  fmt.Println(ans)
}
//  [go]
package main
import(
  "fmt"
  "bufio"
  "os"
  "strconv"
)
var sc=bufio.NewScanner(os.Stdin)
func nextInt() int{
  sc.Scan()
  i, e :=strconv.Atoi(sc.Text())
  if e!=nil{
    panic(e)
  }
  return i
}
func main(){
  var i int
  sc.Split(bufio.ScanWords)
  n:=nextInt()
  a:=make([]int, n)
  for i=0;i<n;i++{
    a[i]=nextInt()
  }
  for i=0;i<n;i++{
    if a[i]>=j{
      ans++
    }
  }
  fmt.Println(ans)
}
//  [ruby]
input_lines = readlines

input_0 = input_lines[0].split(' ')
members_height = input_lines[1].split(' ')
cnt = 0

N = input_0[0]
HEIGHT_LIMIT = input_0[1].to_i

if members_height
  members_height.each do |mem_height|
    cnt = cnt + 1 if mem_height.to_i >= HEIGHT_LIMIT
  end
end
  
puts cnt
//  [ruby]
n,k = gets.split.map(&:to_i)
hs = gets.split.map(&:to_i)

p hs.count{|h| h >= k}
//  [ruby]
_,k = gets.split.map!(&:to_i)
puts gets.split.map!(&:to_i).count{|x| x >= k}
//  [ruby]
n,k=gets.split.map &:to_i
s=gets.split.map &:to_i
s=s.sort.reverse
a=s.bsearch_index{|i|i<k}
if k<s.min
  puts s.size
elsif k>s.max
  puts 0
else
  puts a
end
//  [ruby]
n,k=gets.split.map &:to_i
s=gets.split.map &:to_i
s.sort!
a=s.bsearch_index{|i|i>k}
puts (a==nil)? 0 :a-1
//  [ruby]
n=gets.to_f
if n==1
  puts 1.000
elsif n%2==0
  puts (n/2)/n
else
  puts ((n-1)/2+1)/n
end
//  [rust]
/* {{{ */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
/* }}} */

fn main() {
    input! {
        n: usize,
        k: u32,
        h: [u32;n]
    }
    println!("{}",
        h.iter().filter(|&x| *x >= k).count());
}
/* vim:set foldmethod=marker: */
//  [rust]
use proconio::input;

fn main() {
    input! {
        n: usize,
        k: u32,
        mut h: [u32; n]
    }

    solve(k, &mut h);
}

fn solve(k: u32, h: &mut [u32]) {
    h.sort();
    h.reverse();

    for (i, x) in h.iter().enumerate() {
        if x < &k {
            println!("{}", i);
            return;
        }
    }
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        n: usize,
        k: usize,
        h: [usize;n]
    }
    let ans: i32 = 0;
    for i in 0..n {
        if h.get(i).unwrap() >= &k {
            ans += 1;
        }
    }
    println!("{}", ans);
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        n: usize,
        k: usize,
        h: [usize;n]
    }
    let ans: i32 = 0;
    for i in 0..n {
        if h.get(i).unwrap() >= k {
            ans += 1;
        }
    }
    println!("{}", ans);
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let nk=readInts()
let n=nk[0]
let k=nk[1]
var count=0
let hh=readInts()
for h in hh {
  if h>=k{
    count+=1
  }
}
print(count)
//  [swift]
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

let nk=readInts()
let n=nk[0]
let k=nk[1]
let h=readInts()
var ans=0

for i in h{
  if i>=k {ans+=1}
}

print(ans)
//  [swift]
//
//  main.swift
//
//  Created by sun-yryr
//  Copyright © 2019 sun-yryr. All rights reserved.
//

import Foundation

prefix operator *
prefix func * <T> (a: [T]) -> (T, T) {return (a[0], a[1])}
prefix func * <T> (a: [T]) -> (T, T, T) {return (a[0], a[1], a[2])}


func readInt(separator s: Character = " ") -> [Int] {return readLine()!.split(separator: s).map({Int($0)!})}
func readDouble(separator s: Character = " ") -> [Double] {return readLine()!.split(separator: s).map({Double($0)!})}
func readElement(separator s: Character = " ") -> [String] {return readLine()!.split(separator: s).map({String($0)})}

extension String {
    func at(_ i: Int) -> Character {
        precondition(0 <= i && i < self.count)
        return self[self.index(self.startIndex, offsetBy: i)]
    }
}

func main() {
    let (N, K) = *readInt()
    let h = readInt()
    let size = h.filter{ $0 >= K }.count
    print(size)
}
main()
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let nk=readInts()
let n=nk[0]
let k=nk[1]
var count=0
let hh=readInts()
for h in hh {
  if h>=k{
    count+=1
  }
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let nk=readInts()
let n=nk[0]
let k=nk[1]
var count=0
hh=readInts()
for h in hh {
  if h>=k{
    count+=1
  }
}
//  [swift]

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}
let nk=readInts()
let n=nk[0]
let k=nk[1]
var count=0
hh=readInts()
for h in hh{
  if h>=k{
    count+=1
  }
}
//  [typescript]
import * as fs from 'fs';


//in
// 4 150
// 150 140 100 200
//out
// 2
const main = (inp: string) => {
    const [n, k]: number[] = inp.split('\n')[0].split(' ').map(Number);
    const h: number[] = inp.split('\n')[1].split(' ').map(Number);
    let ans: number = 0;
    for (let i: number = 0; i < n; i++) {
        if (h[i] >= k)
            ans++;
    }
    console.log(ans);
};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
import { readFileSync } from 'fs'
function main() {
  const input = readFileSync('/dev/stdin', 'utf8')
  const data = input.split('\n').map(v => v.trim())
  const [n, k] = data[0].trim().split(' ').map(v => Number(v))
  const friends = data[1].trim().split(' ').map(v => Number(v))
  let count = 0
  for (let i = 0; i < friends.length; i++) {
    if (friends[i] >= k) count++
  }
  console.log(count)

}
main()
//  [typescript]
import * as fs from "fs";

const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
//const n = +input[0];
//const a = [];
//for(let i=0;i<n;i++){
//	a.push(input[i+1].split(" ").map((x:string):number=>+x));
//}

//const [n, m] = input[0].split(" ").map((x: string): number => +x);
//const a = input[1].split(" ").map((x: string): number => +x);

function compareFunc(a, b){
    return a-b;
}

const [n, k]: number[] = input[0].split(' ').map((x: string): number => +x);
const d: number[] = input[1].split(' ').map((x: string): number => +x);

let ans: number = 0;

for(let i = 0; i < n; i++){
    if (d[i] >= k){
        ans++
    }
}
console.log(ans);
//  [typescript]
import * as fs from 'fs';


//in
// 4 150
// 150 140 100 200
//out
// 2
const main = (inp: string) => {
    const [n, k]: number[] = inp.split('\n')[0].split(' ').map(Number);
    const h: number[] = inp.split('\n')[1].split(' ').map(Number);
    let ans: number = 0;
    for (let i: number = 0; i < n; i++) {
        if (h[i] >= k)
            ans++;
    }
    console.log(ans);
};

fs.readFileSync(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
const main = input => {
  const arr = [...input.split("\n")];
  console.log(arr);
  let [numOfPeople, needHeight] = arr[0].split(' ');
  let [...friendHeights] = arr[1].split(' ');
  let count = 0;
  friendHeights.forEach(height => {
    if(height >= needHeight) {
      count++;
    }
  });
  console.log(count);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const main = input => {
  const arr = [...input.split("\n")];
  let [numOfPeople, needHeight] = arr[0].split(' ');
  let [...friendHeights] = arr[1].split(' ');
  let count = 0;
  for(const height of friendHeights) {
    if(height >= needHeight) {
      count++;
    }
  }
  console.log(count);
} 
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
_,*s=open(0)
a=set()
for i in s:a^={i}
print(len(a))
//  [python]
import sys
import collections

read=sys.stdin.buffer.read
readline=sys.stdin.buffer.readline
readlines=sys.stdin.buffer.readlines

N=int(readline())
A=collections.Counter(read().splitlines())

print(len([v for k,v in A.items() if v%2==1]))
//  [python]
# ABC073C - Write and Erase
def main():
    N, *A = map(int, open(0).read().split())
    store = set()
    for a in A:
        if a in store:
            store.remove(a)
        else:
            store.add(a)
    ans = len(store)
    print(ans)


if __name__ == "__main__":
    main()
//  [python]
n=int(input())
L = [0]*(100001)
ans = 0
for  i in range(n):
  L[int(input())] += 1
print(sum([L[i]%2 for i in range(len(L))]))
//  [python]
n=int(input())
A=[int(input()) for i in range(n)]
Aset = set(A)
ans = 0
for a in Aset:
  if A.count(a) % 2 == 1:
    ans += 1
print(ans)
//  [python]
n = int(input())
A = [0]*(10**9+5)
for i in range(n):
    a = int(input())
    A[a-1]+=1
    A[a-1]%=2
print(sum(A))
//  [java]
import java.io.InputStream;
import java.io.IOException;
import java.util.NoSuchElementException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
	public static void main(String args[]) {
		MyInput in = new MyInput();

    int N = in.nextInt();
    int[] num = new int[N];
    for(int i= 0; i< N; i++) {
        num[i] = in.nextInt();
    }
    Arrays.sort(num);
    boolean flag = false;
    int tmp = 0;
    int count = 0;
    for(int i = 0; i < N; i++) {
        if(tmp == num[i]) {
            flag ^= true;
        }else {
            if(flag) count++;
            flag = true;
            tmp = num[i];
        }
    }
    if(flag)count++;

    System.out.println(count);
	}
}

class MyInput {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr= 0;
	private int buflen = 0;
	private boolean hasNextByte() {
		if(ptr < buflen) {
			return true;
		}else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch(IOException e) {
				e.printStackTrace();
			}
			if(buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	public int readByte() { 
		if (hasNextByte()) return buffer[ptr++];
		else return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <=126;
	}

	private void skipUnprintable() {
		while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
	}

	public boolean hasNext() {
		skipUnprintable();
		return hasNextByte();
	}

	public String next() {
		if(!hasNext()) throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while(isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if(!hasNext()) throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if(b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while(true) {
			if('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			}else if(b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			}else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}

	public int nextInt() {
		long nl = nextLong();
		if(nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
		return (int) nl;
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
}
//  [java]
/**
 * DA-IICT
 * Author : PARTH PATEL
 */
import java.io.*;
import java.math.*;
import java.util.*;

import static java.util.Arrays.fill;
import static java.lang.Math.*;
import static java.util.Arrays.sort;
import static java.util.Collections.sort;


 class Main {

	public static int mod = 1000000007;
	static FasterScanner in = new FasterScanner();
	static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {

		int n=in.nextInt();
		Set<Integer> set=new HashSet<>();
		while(n-->0)
		{
			int x=in.nextInt();
			if(set.contains(x))
				set.remove(x);
			else
				set.add(x);
		}
		out.println(set.size());
		out.close();

	}

	public static long pow(long x, long n, long mod) {
		long res = 1;
		for (long p = x; n > 0; n >>= 1, p = (p * p) % mod) {
			if ((n & 1) != 0) {
				res = (res * p % mod);
			}
		}
		return res;
	}

	public static long gcd(long n1, long n2) {
		long r;
		while (n2 != 0) {
			r = n1 % n2;
			n1 = n2;
			n2 = r;
		}
		return n1;
	}

	static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int snumChars;

		public int read() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = System.in.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}

}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.NoSuchElementException;
import java.util.Set;

public class Main {

	static void exec(MyScanner in, PrintWriter out) {
		int N = in.nextInt();
		Set<Integer> set = new HashSet<>(N);
		for (int i = 0; i < N; i += 1) {
			int a = in.nextInt();
			if (!set.add(a)) {
				set.remove(a);
			}
		}
		out.println(set.size());
	}

	public static void main(String[] args) {
		PrintWriter w = new PrintWriter(System.out);
		exec(new MyScanner(System.in), w);
		w.flush();
	}

	static class MyScanner {
		static final int BUFFER_SIZE = 1024;
		private final InputStream in;
		private final byte[] buffer = new byte[BUFFER_SIZE];
		private int point;
		private int readLength;
		MyScanner(InputStream in) {
			this.in = in;
		}
		private int readByte() {
			if (point < readLength) {
				int result = buffer[point];
				point += 1;
				return result;
			}
			try {
				readLength = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (readLength == -1) {
				return -1;
			}
			point = 1;
			return buffer[0];
		}
		static boolean isPrintableCharExceptSpace(int c) {
			return 33 <= c && c <= 126;
		}
		String next() {
			StringBuilder b = new StringBuilder();
			int c = readByte();
			while (!(c == -1 || isPrintableCharExceptSpace(c))) {
				c = readByte();
			}
			if (c == -1) {
				throw new NoSuchElementException();
			}
			do {
				b.appendCodePoint(c);
				c = readByte();
			} while (c != -1 && isPrintableCharExceptSpace(c));
			return b.toString();
		}
		long nextLong() {
			int c = readByte();
			while (!(c == -1 || isPrintableCharExceptSpace(c))) {
				c = readByte();
			}
			if (c == -1) {
				throw new NoSuchElementException();
			}
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			long result = 0L;
			do {
				if (!('0' <= c && c <= '9')) {
					throw new InputMismatchException();
				}
				result = result * 10L + (c - '0');
				c = readByte();
			} while (c != -1 && isPrintableCharExceptSpace(c));
			return minus ? -result : result;
		}
		int nextInt() {
			long n = nextLong();
			if (Integer.MIN_VALUE <= n && n <= Integer.MAX_VALUE) {
				return (int) n;
			}
			throw new InputMismatchException();
		}
		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

}
//  [java]
import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
    public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		PrintWriter ou = new PrintWriter(System.out);
		int n = Integer.parseInt(sc.next());
		int[] a = new int[n];
		for(int i = 0 ; i < n ; i++) a[i] = Integer.parseInt(sc.next());
		sc.close();
		Arrays.sort(a);
		int yono = 0;
		int k = 0;
		for(int i = 1 ; i < n ; i++){
			if(a[i - 1] == a[0]) k++;
			else{
				yono += k % 2;
				k = 1;
			}
		}
		k--;
		yono += k % 2;
		ou.println(yono);
		ou.flush();
	}
}
//  [java]

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		//入力データを変数で受け取る
		int n = sc.nextInt();
		List<Integer> list = new ArrayList<>();

		for(int i = 0; i < n; i++) {
			int num = sc.nextInt();
			if(list.contains(num)) {
				int index = list.indexOf(num);
				list.remove(index);
			} else {
				list.add(num);
			}
		}

		System.out.println(list.size());

		//入力データを処理して、結果を出力


	}
}
//  [java]
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        Main m = new Main(sc);
        m.show(m.solve());
        sc.close();
    }
    
	//フィールド
    Scanner sc;
    int N;
    int[] A;
    
    //入力
    Main(Scanner sc) {
        this.sc = sc;
        this.N = sc.nextInt();
        A = new int[N];
        for (int i=0; i<N; i++) {
        	A[i] = sc.nextInt();
        }
    }
    
    //解答処理
    private int solve() {
        int answer = 0;
        List<Integer> paper = new ArrayList<Integer>();
        for (int i=0; i<N; i++) {
        	if (paper.contains(A[i])) {
        		paper.remove(paper.indexOf(A[i]));
        	} else {
        		paper.add(A[i]);
        	}
        }
        answer = paper.size();
        return answer;
    }
    
    //出力
    public void show(int answer) {
        System.out.println(answer);
    }

}
//  [cpp]
//#include<bits/stdc++.h>
#include<cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please

const int cm = 1 << 17;
char cn[cm], * ci = cn + cm, ct;
inline char getcha() {
	if (ci - cn == cm) { fread(cn, 1, cm, stdin); ci = cn; }
	return *ci++;
}
inline int getint() {
	int A = 0;
	if (ci - cn + 16 > cm) while ((ct = getcha()) >= '0') A = A * 10 + ct - '0';
	else while ((ct = *ci++) >= '0') A = A * 10 + ct - '0';
	return A;
}

void pakuri_sort(int N, int A[]) {
	const int b = 8;
	int tmp[100001];
	rep(k, 4) {
		int kazu[1 << b] = {}, kazu2[1 << b] = {};
		rep(i, N) kazu[A[i] >> k * b & ((1 << b) - 1)]++;
		rep(i, (1 << b) - 1) kazu[i + 1] += kazu[i];
		for (int i = N - 1; i >= 0; i--) tmp[--kazu[A[i] >> k * b & ((1 << b) - 1)]] = A[i];
		k++;
		rep(i, N) kazu2[tmp[i] >> k * b & ((1 << b) - 1)]++;
		rep(i, (1 << b) - 1) kazu2[i + 1] += kazu2[i];
		for (int i = N - 1; i >= 0; i--) A[--kazu2[tmp[i] >> k * b & ((1 << b) - 1)]] = tmp[i];
	}
}

int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);


	int N = getint();
	int A[100000];
	rep(i, N) A[i] = getint();

	pakuri_sort(N, A);
	int kotae = 0;
	int kazu = 1;
	rep(i, N - 1) {
		if (A[i] == A[i + 1]) kazu++;
		else {
			kotae += kazu & 1;
			kazu = 1;
		}
	}
	kotae += kazu & 1;
	printf("%d", kotae);

	Would you please return 0;
}
//  [cpp]
//#include<bits/stdc++.h>
#include<cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please

const int cm = 1 << 17;
char cn[cm], * ci = cn + cm, ct;
inline char getcha() {
	if (ci - cn == cm) { fread_unlocked(cn, 1, cm, stdin); ci = cn; }
	return *ci++;
}
inline int getint() {
	int A = 0;
	if (ci - cn + 16 > cm) while ((ct = getcha()) >= '0') A = A * 10 + ct - '0';
	else while ((ct = *ci++) >= '0') A = A * 10 + ct - '0';
	return A;
}

void pakuri_sort(int N, int A[]) {
	const int b = 8;
	int tmp[200001];
	rep(k, 4) {
		int kazu[1 << b] = {}, kazu2[1 << b] = {};
		rep(i, N) kazu[A[i] >> k * b & ((1 << b) - 1)]++;
		rep(i, (1 << b) - 1) kazu[i + 1] += kazu[i];
		for (int i = N - 1; i >= 0; i--) tmp[--kazu[A[i] >> k * b & ((1 << b) - 1)]] = A[i];
		k++;
		rep(i, N) kazu2[tmp[i] >> k * b & ((1 << b) - 1)]++;
		rep(i, (1 << b) - 1) kazu2[i + 1] += kazu2[i];
		for (int i = N - 1; i >= 0; i--) A[--kazu2[tmp[i] >> k * b & ((1 << b) - 1)]] = tmp[i];
	}
}

int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);


	int N = getint();
	int A[100000];
	rep(i, N) A[i] = getint();
	pakuri_sort(N, A);
	int kotae = 0;
	int mae = -1;
	int k = 0;
	rep(i, N) {
		if (mae != A[i]) {
			kotae += k;
			k = 1;
			mae = A[i];
		}
		else k ^= 1;
	}
	printf("%d", kotae + k);

	Would you please return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define inf 1000000005
#define mod 1000000007
#define eps 1e-10
#define rep(i,n) for(int i = 0; i < (n); ++i) /*0からn-1までのrepeat*/
#define rrep(i,n) for(int i = 1; i <= (n); ++i) /*1からnまでのrepeat*/
#define drep(i,n) for(int i = (n)-1; i >= 0; --i) /*n-1から0までのrepeat*/
#define srep(i,s,t) for (int i = s; i < t; ++i) /*sからt-1までのrepeat*/
#define isin(x,l,r) ((l) <= (x) && (x) < (r)) /*l以上r未満のx*/
#define each(a,b) for(auto& (a): (b)) /*よくわからん*/
#define pct __builtin_popcountll /*1bitの数*/
#define all(a) a.begin(),a.end() /*範囲*/
#define sz(v) (int)(v).size() /*大きさ*/
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end()) /*重複削除*/
#define cmx(x,y) x=max(x,y) /*最大*/
#define cmn(x,y) x=min(x,y) /*最小*/
#define rev(v) reverse((v).begin(),(v).end()); /*逆順*/
#define so(v) sort((v).begin(), (v).end()); /*ソート*/
#define yn {puts("Yes");}else{puts("No");} /*はい・いいえ*/
#define dame { puts("-1"); return 0;}/*だめ*/
#define fi first
#define se second
#define pb push_back
#define eb emplace_back

using namespace std;

using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int,int>;
using T = tuple<int, int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vp = vector<P>;
using vt = vector<T>;
using vs = vector<string>; 

int main(){
    int n,p,q,r,ct;
    cin >> n;
    vi a;
    rep(i, n) {
        cin >> p;
        a.push_back(p);
        q=sz(a);
        zip(a);
        r = sz(a);
        if (q!=r) {
            a.erase(remove(all(a), p),a.end());
        }
    }
    cout << sz(a) << endl;
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define inf 1000000005
#define mod 1000000007
#define eps 1e-10
#define rep(i,n) for(int i = 0; i < (n); ++i) /*0からn-1までのrepeat*/
#define rrep(i,n) for(int i = 1; i <= (n); ++i) /*1からnまでのrepeat*/
#define drep(i,n) for(int i = (n)-1; i >= 0; --i) /*n-1から0までのrepeat*/
#define srep(i,s,t) for (int i = s; i < t; ++i) /*sからt-1までのrepeat*/
#define isin(x,l,r) ((l) <= (x) && (x) < (r)) /*l以上r未満のx*/
#define each(a,b) for(auto& (a): (b)) /*よくわからん*/
#define pct __builtin_popcountll /*1bitの数*/
#define all(a) a.begin(),a.end() /*範囲*/
#define sz(v) (int)(v).size() /*大きさ*/
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end()) /*重複削除*/
#define cmx(x,y) x=max(x,y) /*最大*/
#define cmn(x,y) x=min(x,y) /*最小*/
#define rev(v) reverse((v).begin(),(v).end()); /*逆順*/
#define so(v) sort((v).begin(), (v).end()); /*ソート*/
#define yn {puts("Yes");}else{puts("No");} /*はい・いいえ*/
#define dame { puts("-1"); return 0;}/*だめ*/
#define fi first
#define se second
#define pb push_back
#define eb emplace_back

using namespace std;

using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int,int>;
using T = tuple<int, int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vp = vector<P>;
using vt = vector<T>;
using vs = vector<string>; 

int main(){
    int n,p,q,r,ct;
    cin >> n;
    vi a;
    rep(i, n) {
        cin >> p;
        a.push_back(p);
        q=a.size();
        zip(a);
        r = a.size();
        if (q!=r) {
            a.erase(remove(a.begin(),a.end(), p),a.end());
        }
    }
    ct = a.size();
    cout << ct << endl;
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define inf 1000000005
#define mod 1000000007
#define eps 1e-10
#define rep(i,n) for(int i = 0; i < (n); ++i) /*0からn-1までのrepeat*/
#define rrep(i,n) for(int i = 1; i <= (n); ++i) /*1からnまでのrepeat*/
#define drep(i,n) for(int i = (n)-1; i >= 0; --i) /*n-1から0までのrepeat*/
#define srep(i,s,t) for (int i = s; i < t; ++i) /*sからt-1までのrepeat*/
#define isin(x,l,r) ((l) <= (x) && (x) < (r)) /*l以上r未満のx*/
#define each(a,b) for(auto& (a): (b)) /*よくわからん*/
#define pct __builtin_popcountll /*1bitの数*/
#define all(a) a.begin(),a.end() /*範囲*/
#define sz(v) (int)(v).size() /*大きさ*/
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end()) /*重複削除*/
#define cmx(x,y) x=max(x,y) /*最大*/
#define cmn(x,y) x=min(x,y) /*最小*/
#define rev(v) reverse((v).begin(),(v).end()); /*逆順*/
#define so(v) sort((v).begin(), (v).end()); /*ソート*/
#define yn {puts("Yes");}else{puts("No");} /*はい・いいえ*/
#define dame { puts("-1"); return 0;}/*だめ*/
#define fi first
#define se second
#define pb push_back
#define eb emplace_back

using namespace std;

using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int,int>;
using T = tuple<int, int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vd = vector<double>;
using vp = vector<P>;
using vt = vector<T>;
using vs = vector<string>; 

int main(){
    int n,p,q,r,ct;
    cin >> n;
    vi a;
    rep(i, n) {
        cin >> p;
        a.push_back(p);
        q=sz(a);
        so(a);
        r = sz(a);
        if (q-r==1) {
            a.erase(remove(all(a), p),a.end());
        }
    }
    cout << sz(a) << endl;
    return 0;
}