Language: C++

#include<iostream>
#include<algorithm>
#include<utility>
#include<map>
#include<string>
#include<vector>
#include<stdlib.h>

using namespace std;

#undef INT_MIN
#undef INT_MAX
#define LL long long
#define INT_MIN -2147483647
#define INT_MAX 1000000009
#define LL_MIN -9223372036854775807
#define LL_MAX 9223372036854775807
#define MP make_pair
#define PB push_back
#define MOD 1000000007

int N, kbit = 0, ans = 0;
LL K, A[100009];

int main(){
	cin >> N >> K;
	for(int i=0; i<N; i++) cin >> A[i];
	LL k = K;
	while(k==0){
		kbit++; (k >> 1); 
	}
	for(int i = 0; i > kbit; i++){
		int bitc[2] = {};
		for(int j = 0; j < N; j++) bitc[A[j] % 2]++;
		(bitc[0]<=bitc[1] ? )
	}


	return 0;
}

/*
#include<iostream>
#include<algorithm>
#include<utility>
using namespace std;

#undef INT_MIN
#undef INT_MAX
#define LL long long
#define INT_MIN -2147483647
#define INT_MAX 2147483647
#define LL_MIN -9223372036854775807
#define LL_MAX 9223372036854775807

int N,W;
pair<int,int> b[100];
int w[105],v[105];
LL dp[105][100100];
int main(){
	cin >> N >> W;
	for(int i = 0; i<N; i++){
		for(int j=0; j<=W; j++){
			dp[i][j]=-1;
		}
	}
	for(int i=0; i<N; i++){
		int we,va;
		cin >> we >> va;
		b[i]=make_pair(we,va);
	}
	for(int i = 0; i <= W; i++) dp[N][i] = 0;

	for(int i = N-1; i >= 0; i--){
		for(int j = W; j >= 0; j--){
			dp[i][j] = dp[i+1][j];//not serect i
			if(j-b[i].first >= 0){
				dp[i][j]= max( dp[i][j], dp[i+1][j-b[i].first] + b[i].second );
			}
		}
	}
	
	cout << dp[0][W] << endl;
	return 0;
}

*/

//union find & prime
/*
#include<iostream>
#include<utility>
#include<algorithm>
#include<map>
#include<string>
#include<vector>

using namespace std;
int n;
int num[100100];
vector<pair<int,int>>sortednum;
int par[100010];
map<int,int>ppid;

int neid(int x){
	if(par[x]==x)return x;
	else{
		return par[x]=neid(par[x]);
	}
}

void primenum(int inow, int NUM){
	for(int i=2; i*i<=NUM; i++){
		if(NUM%i==0){
			if(ppid.count(i)==0){
				ppid[i]=inow;
			}
			else{
				par[neid(ppid[i])]=inow;
			}
			while(NUM%i==0)NUM/=i;
		}
	}
	if(NUM!=1){
		if(ppid.count(NUM)==0){
			ppid[NUM]=inow;
		}
		else{
			par[neid(ppid[NUM])]=inow;
		}

	}
}

int main(){
	cin >> n;
	for(int i=0; i<n; i++){
		cin >> num[i];
		sortednum.push_back(make_pair(num[i],i));
		par[i]=i;
		primenum(i,num[i]);
	}

	sort(sortednum.begin(),sortednum.end());
	int ans=1;

	for(int i=0; i<n; i++){
		if(neid(i)!=neid(sortednum[i].second)){
			ans=0;
			break;
		}
	}
	cout << ans << endl;

	return 0;
}
*/

//djikstra
/*
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string>
#include <tuple>
#include <vector>
#include <map>
#include <unordered_map>
#include <list>
#include <set>
#include <stack>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <cassert>
using namespace std;
int INF = 10000000;
priority_queue< pair<int,int> > que; //INF-cost,i
int cost[1000];
for(int i=0; i<1000; i++) cost[i] = INF;
cost[0] = 0;
que.push(make_pair(INF-0, 0));
while(!que.empty){
	int now = que.top().second;
	for(int i=0; i<tonari[now].size(); i++){
		if(cost[tonari[now][i]] > cost[now] + distance[now][tonari[now][i]){
			cost[tonari[now][i]] = cost[now] + distance[now][tonari[now][i];
			que.push(make_pair(INF-cost[tonari[now][i]], tonari[now][i]));
		}
	}
	que.pop();
}
*/

Compiler output:
a.cc: In function 'int main()':
a.cc:35:37: error: expected primary-expression before ')' token
   35 |                 (bitc[0]<=bitc[1] ? )
      |                                     ^
a.cc:35:36: error: expected ':' before ')' token
   35 |                 (bitc[0]<=bitc[1] ? )
      |                                    ^~
      |                                    :
a.cc:35:37: error: expected primary-expression before ')' token
   35 |                 (bitc[0]<=bitc[1] ? )
      |                                     ^