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

#include<algorithm>

#include<vector> 

#include<map>

using namespace std;

const int M=1e5+5;

struct node{

	int p,y;

	int k,num;

}q;

bool comp(node a,node b){

	return a.y<b.y;

}

vector<node> a[M];

map<int,node> Map;

int main(){

    int n,m;

    cin>>n>>m;

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

    	int p,y;

    	cin>>p>>y;

    	q.p=p; q.y=y;

    	q.k=i;

    	Map[i]=q;

    	a[p].push_back(q);

	}

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

		sort(a[i].begin(),a[i].end(),comp);

		for(int j=0;j<a[i].size();j++)

			Map[a[i][j].k].num=j+1;	

	}

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

		printf("%06d%06d\n",Map[i].p,Map[i].num);

}

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

#include<algorithm>

using namespace std;

struct ss{

    int rank;

    int p;

    int y;

}a[100005];

int cmp(ss x,ss y){

    if(x.p!=y.p) return x.p<y.p;

    else return x.y<y.y;

}

int main()

{

    int n ,m;

    scanf("%d%d",&n,&m);

    int b[100005];

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

        a[i].rank=i;

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

        b[i]=a[i].p;

    }

    sort(a,a+m,cmp);

    int f=a[0].p,flag=1;

    int x[100005];

    

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

        if(a[i].p!=f) {flag=1;f=a[i].p;}

        x[a[i].rank]=flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);

    return 0;



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

#include <cstdlib>



typedef struct {

    int idx;

    int per;

    int year;

    char id[16];

} City;



int compCity(const void* aa, const void* bb) {

    City* a = (City*)aa;

    City* b = (City*)bb;



    if (a->per < b->per) return -1;

    else if (a->per > b->per) return 1;

    else if (a->year < b->year) return -1;

    return 1;

}



int compIdx(const void* aa, const void* bb) {

    City* a = (City*)aa;

    City* b = (City*)bb;



    if (a->idx < b->idx) return -1;

    return 1;

}



int main() {

    int N = 0, M = 0;

    scanf("%d %d", &N, &M);

    City *city = new City[M]();

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

        city[i].idx = i;

        scanf("%d %d", &(city[i].per), &(city[i].year));

    }



    qsort(city, M, sizeof(City), compCity);



    for (int i = 0, j = 1, p = city[0].per; i < M; i++) {

        if (p != city[i].per) {

            j = 1;

            p = city[i].per;

        }

        sprintf(city[i].id, "%06d%06d", p, j++);

    }



    qsort(city, M, sizeof(City), compIdx);



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

        printf("%s\n", city[i].id);

    }



    delete[] city;

    return 0;

}


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

#include<algorithm>

using namespace std;

struct ss{

    int rank;

    int p;

    int y;

}a[100005];

int cmp(ss x,ss y){

    if(x.p!=y.p) return x.p<y.p;

    else return x.y<y.y;

}

int main()

{

    int n ,m;

    scanf("%d%d",&n,&m);

    int b[100005];

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

        a[i].rank=i;

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

        b[i]=a[i].p;

    }

    sort(a,a+m,cmp);

    int f=a[0].p,flag=1;

    int x[100005];

    

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

        if(a[i].p!=f) {flag=1;f=a[i].p;}

        x[a[i].rank]=flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);

    return 0;



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

#include <algorithm>

#include <cstring>

#include <cstdio>

#include <vector>

#include <queue>

#include <stack>

#include <cstdlib>

#include <iomanip>

#include <cmath>

#include <cassert>

#include <ctime>

#include <cstdlib>

#include <map>

#include <set>

using namespace std;

#pragma comment(linker, "/stck:1024000000,1024000000")

#define lowbit(x) (x&(-x))

#define max(x,y) (x>=y?x:y)

#define min(x,y) (x<=y?x:y)

//#define MAX 100000000000000000

#define MOD 1000000007

#define pi acos(-1.0)

#define ei exp(1)

#define PI 3.1415926535897932384626433832

#define ios() ios::sync_with_stdio(true)

#define INF (1<<31)-1;

#define mem(a) (memset(a,0,sizeof(a)))

struct P{

    int x,y;

}H[200000];

vector<int>G[200000];

int POS(int k,int value){

    int mid;

    int left = 0;

    int len = G[k].size();

    int right = len - 1;

    //cout<<" "<<k<<"A"<<value<<endl;

    while(left <= right){

 

        // 确保中点靠近区间的起点

        mid = left + (right-left)/2;

        //cout<<mid<<endl;

        //cout<<"mid= "<<mid<<" "<<left<<" "<<right<<endl;

        // 如果找到则返回

        if(G[k][mid] == value) return mid;

        // 将中点赋给终点

        else if(G[k][mid] > value) right = mid;

        // 将中点加一赋给起点

        else left = mid + 1;

    }

    return -1;

}

set<int>::iterator it;

int main()

{

    set<int>s;

    int N,M;

    int x,y;

    cin>>N>>M;

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

        cin>>x>>y;

        H[i].x = x;

        H[i].y = y;

        G[x].push_back(y);

        s.insert(x);

    }

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

        sort(G[i].begin(),G[i].end());

    }

 

 

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

        cout<<setw(6)<<setfill('0')<<H[i].x;

        cout<<setw(6)<<setfill('0')<<POS(H[i].x,H[i].y)+1<<endl;

    }

    return 0;

}

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

#include<algorithm>

using namespace std;

struct ss{

    int rank;

    int p;

    int y;

}a[100005];

int cmp(ss x,ss y){

    if(x.p!=y.p) return x.p<y.p;

    else return x.y<y.y;

}

int main()

{

    int n ,m;

    scanf("%d%d",&n,&m);

    int b[100005];

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

        a[i].rank=i;

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

        b[i]=a[i].p;

    }

    sort(a,a+m,cmp);

    int f=a[0].p,flag=1;

    int x[100005];

    

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

        if(a[i].p!=f) {flag=1;f=a[i].p;}

        x[a[i].rank]=flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);

    return 0;



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

#include<iostream>

#include<algorithm>



using namespace std;



struct temp

{

    int rank;

    int p;

    int y;

}a[100005];



int cmp(temp x, temp y)

{

    if(x.p != y.p)

        return x.p<y.p;

    else

        return x.y<y.y;

}



int main()

{

    int n,m;

    while(cin >> n >> m)

    {

        int b[100005];

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

    {

        a[i].rank = i;

        cin >> a[i].p >> a[i].y;

        b[i] = a[i].p;

    }



    sort(a,a+m,cmp);

    int f = a[0].p,flag = 1;

    int x[100005];



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

    {

        if(a[i].p != f)

        {

            flag = 1;

            f = a[i].p;

        }

        x[a[i].rank] = flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);



    }

    return 0;

}


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

#include<algorithm>

using namespace std;

struct ss{

    int rank;

    int p;

    int y;

}a[100005];

int cmp(ss x,ss y){

    if(x.p!=y.p) return x.p<y.p;

    else return x.y<y.y;

}

int main()

{

    int n ,m;

    scanf("%d%d",&n,&m);

    int b[100005];

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

        a[i].rank=i;

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

        b[i]=a[i].p;

    }

    sort(a,a+m,cmp);

    int f=a[0].p,flag=1;

    int x[100005];

    

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

        if(a[i].p!=f) {flag=1;f=a[i].p;}

        x[a[i].rank]=flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);

    return 0;



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

using namespace std;



const int N = 1e5+5;



struct node{

    int aa,bb;

};



int main()

{

    int n,m,i,j,k;

    cin>>n>>m;

    int p[m+2],y[m+2];

    //priority_queue < pair<int,int> > pq;

    //map < node ,int> mp;

    map < pair<int,int> ,int> mp;

    map < int, vector<int> > v;

    set <int> st;

    //node pp;

    pair <int,int> pp;



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

    {

        cin>>p[i]>>y[i];

        v[p[i]].push_back(y[i]);

        st.insert(p[i]);

    }



    for(auto ii: st)

    {

        sort(v[ii].begin(),v[ii].end());

        for(i=0; i<v[ii].size(); i++)

        {

            //pp.aa=ii;

            //pp.bb=v[ii][i];

            pp= make_pair(ii,v[ii][i]);

            mp[pp]=i+1;

        }

    }





    string s;



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

    {

        s="000000000000";



        k=p[i];

        j=5;

        while(k)

        {

            s[j--]=(char) (k%10)+'0';

            k/=10;

        }

        ///////////////

        pp= make_pair(p[i],y[i]);

        //pp.aa=p[i];

        //pp.bb=y[i];

        k=mp[pp];

        j=11;

        while(k)

        {

            s[j--]=(char) (k%10)+'0';

            k/=10;

        }



        cout<<s<<endl;

    }





    return 0;

}


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

#include<algorithm>

using namespace std;

struct ss{

    int rank;

    int p;

    int y;

}a[100005];

int cmp(ss x,ss y){

    if(x.p!=y.p) return x.p<y.p;

    else return x.y<y.y;

}

int main()

{

    int n ,m;

    scanf("%d%d",&n,&m);

    int b[100005];

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

        a[i].rank=i;

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

        b[i]=a[i].p;

    }

    sort(a,a+m,cmp);

    int f=a[0].p,flag=1;

    int x[100005];

    

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

        if(a[i].p!=f) {flag=1;f=a[i].p;}

        x[a[i].rank]=flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);

    return 0;



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

using namespace std;

#define ll long long int

int main()

{

    ll n,m;

    cin>>n>>m;

    vector<pair<ll,ll> >pr(m);

    map<ll,pair<ll,ll> >mp;

    vector<ll>v(m);

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

    {

        cin>>pr[i].first>>pr[i].second;

        v[i] = pr[i].second;

    }

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

    ll c=1;



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

    {

        mp.insert({pr[i].second,{pr[i].first,c}});

        ++c;

    if(pr[i].first!=pr[i+1].first)

            c = 1;

    }



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

    {

        printf("%.6lld%.6lld\n",mp[v[i]].first,mp[v[i]].second);

    }

}


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

#include<algorithm>

using namespace std;

struct ss{

    int rank;

    int p;

    int y;

}a[100005];

int cmp(ss x,ss y){

    if(x.p!=y.p) return x.p<y.p;

    else return x.y<y.y;

}

int main()

{

    int n ,m;

    scanf("%d%d",&n,&m);

    int b[100005];

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

        a[i].rank=i;

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

        b[i]=a[i].p;

    }

    sort(a,a+m,cmp);

    int f=a[0].p,flag=1;

    int x[100005];

    

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

        if(a[i].p!=f) {flag=1;f=a[i].p;}

        x[a[i].rank]=flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);

    return 0;



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

#include<algorithm>

#include<stdio.h>

#include<string.h>

#include<vector>

using namespace std;

typedef  long long ll;

int N,M,P,Y;

const int maxm=(int)1e5+5;

struct city{

int p;

int y;

int i;

int flag;

city(){

    flag = 0;

}

};

city C[maxm];

int tot;

bool cmp1(city city1,city city2){

    return city1.p<city2.p ||(city1.p==city2.p&&city1.y<city2.y);

}

bool cmp2(city city1,city city2){

    return city1.i<city2.i;

}

int main(){

    scanf("%d%d",&N,&M);

    tot=0;

    memset(C,0,sizeof(C));

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

        struct city tmp;

        scanf("%d%d",&P,&Y);

        tmp.p=P;tmp.y=Y;tmp.i=i;

        C[tot]=tmp;

        tot++;

    }

    sort(C,C + M,cmp1);

    C[0].flag=1;

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

        if(C[i].p==C[i-1].p)C[i].flag=C[i-1].flag+1;

        else C[i].flag=1;

    }

     sort(C,C + M,cmp2);

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

        printf("%06d%06d\n",C[i].p,C[i].flag);

     }

    //for(int i=0;i<M;i++)

      //  cout<<"p:"<<C[i].p<<"y:"<<C[i].y<<"flag:"<<C[i].flag<<"i:"<<C[i].i<<endl;

    return 0;

}


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

#include<algorithm>

using namespace std;

struct ss{

    int rank;

    int p;

    int y;

}a[100005];

int cmp(ss x,ss y){

    if(x.p!=y.p) return x.p<y.p;

    else return x.y<y.y;

}

int main()

{

    int n ,m;

    scanf("%d%d",&n,&m);

    int b[100005];

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

        a[i].rank=i;

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

        b[i]=a[i].p;

    }

    sort(a,a+m,cmp);

    int f=a[0].p,flag=1;

    int x[100005];

    

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

        if(a[i].p!=f) {flag=1;f=a[i].p;}

        x[a[i].rank]=flag++;

    }



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

        printf("%06d%06d\n",b[i],x[i]);

    return 0;



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

#include <algorithm>

#include <cstring>

#include <cstdio>

#include <vector>

#include <queue>

#include <stack>

#include <cstdlib>

#include <iomanip>

#include <cmath>

#include <cassert>

#include <ctime>

#include <cstdlib>

#include <map>

#include <set>

using namespace std;

#pragma comment(linker, "/stck:1024000000,1024000000")

#define lowbit(x) (x&(-x))

#define max(x,y) (x>=y?x:y)

#define min(x,y) (x<=y?x:y)

//#define MAX 100000000000000000

#define MOD 1000000007

#define pi acos(-1.0)

#define ei exp(1)

#define PI 3.1415926535897932384626433832

#define ios() ios::sync_with_stdio(true)

#define INF (1<<31)-1;

#define mem(a) (memset(a,0,sizeof(a)))

struct P{

    int x,y;

}H[200000];

vector<int>G[200000];

int POS(int k,int value){

    int mid;

    int left = 0;

    int len = G[k].size();

    int right = len - 1;

    //cout<<" "<<k<<"A"<<value<<endl;

    while(left <= right){

 

        // 确保中点靠近区间的起点

        mid = left + (right-left)/2;

        //cout<<mid<<endl;

        //cout<<"mid= "<<mid<<" "<<left<<" "<<right<<endl;

        // 如果找到则返回

        if(G[k][mid] == value) return mid;

        // 将中点赋给终点

        else if(G[k][mid] > value) right = mid;

        // 将中点加一赋给起点

        else left = mid + 1;

    }

    return -1;

}

set<int>::iterator it;

int main()

{

    set<int>s;

    int N,M;

    int x,y;

    cin>>N>>M;

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

        cin>>x>>y;

        H[i].x = x;

        H[i].y = y;

        G[x].push_back(y);

        s.insert(x);

    }

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

        sort(G[i].begin(),G[i].end());

    }

 

 

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

        cout<<setw(6)<<setfill('0')<<H[i].x;

        cout<<setw(6)<<setfill('0')<<POS(H[i].x,H[i].y)+1<<endl;

    }

    return 0;

}

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

#include <algorithm>

#include <string>

using namespace std;



struct CITY{

    //int id;

    int p;

    int year;

    int no;

};

CITY citys[100000];

string ids[100000];



int cmp(CITY a, CITY b)

{

    if(a.p!=b.p)

    {

        return a.p<b.p;

    }

    else

    {

        return a.year<b.year;

    }

}



string id2String(int data)

{

    string s="";

    int i,d;

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

    {

        d = data%10;

        data = data/10;

        s = to_string(d)+s;

    }

    return s;

}





int main()

{

 int N,M;

 int i,j,number=1,p_pre=0,data2;

 char s[6],d[6],id[12];



 cin>>N>>M;

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

 {

     citys[i].no = i;

     cin>>citys[i].p>>citys[i].year;

 }

 sort(citys, citys+M,cmp);



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

 {

     if(p_pre == citys[i].p)

     {

        number++;

     }

     else

     {

         number=1;

         p_pre = citys[i].p;

     }

     ids[citys[i].no] = id2String(citys[i].p)+id2String(number);

 }



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

 {

    cout<<ids[i]<<endl;

 }

 return 0;

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

#include<algorithm>

#include<vector>

#include<map>

using namespace std;

const int maxn = 1e5 + 1;

struct node{

	int p,y;

	int num;

	int sub;

}no;

vector<node> v[maxn];

bool cmp(node a,node b){

	return a.y<b.y;

}

int main(){

	int n,m,p,y;

	cin>>n>>m;

	map<int,node> Map;

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

		cin>>p>>y;

		no.p=p;no.y=y;

		no.sub=i;

		Map[i]=no;

		v[p].push_back(no);

	}

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

		sort(v[i].begin(),v[i].end(),cmp);

		for (int j=0;j<v[i].size();j++){

        	Map[v[i][j].sub].num=j+1;

    	}

	}

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

		printf("%06d%06d\n",Map[i].p,Map[i].num);

	}

	return 0;

}

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

using namespace std;



struct T{

	int y, p, i, j;

}a[100005];



bool cmp(T a, T b){

	if(a.y == b.y)

		return a.p < b.p;

	return a.y < b.y;

}



bool cmp1(T a, T b){

	return a.i < b.i;

}



int main(){

	int n, m;

	cin >> n >> m;

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

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

		a[i].i = i;

	}

	sort(a+1,a+1+m,cmp);

//	for(int i = 1; i <= m; i++)

//		printf("%d %d\n",a[i].y,a[i].p);	

	int x = 1, y = 1;

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

		if(a[i].y > x){

			x = a[i].y;

			y = 1;	

		}

		a[i].j = y++;

//		printf("%06d%06d\n",x,y++);

	}

	sort(a+1,a+1+m,cmp1);

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

		printf("%06d%06d\n",a[i].y,a[i].j);

	return 0;

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

#include<algorithm>

#include<vector> 

#include<map>

using namespace std;

const int M=1e5+5;

struct node{

	int p,y;

	int k,num;

}q;

bool comp(node a,node b){

	return a.y<b.y;

}

vector<node> a[M];

map<int,node> Map;

int main(){

    int n,m;

    cin>>n>>m;

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

    	int p,y;

    	cin>>p>>y;

    	q.p=p; q.y=y;

    	q.k=i;

    	Map[i]=q;

    	a[p].push_back(q);

	}

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

		sort(a[i].begin(),a[i].end(),comp);

		for(int j=0;j<a[i].size();j++)

			Map[a[i][j].k].num=j+1;	

	}

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

		printf("%06d%06d\n",Map[i].p,Map[i].num);

}

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

using namespace std;



struct T{

	int y, p, i, j;

}a[100005];



bool cmp(T a, T b){

	if(a.y == b.y)

		return a.p < b.p;

	return a.y < b.y;

}



bool cmp1(T a, T b){

	return a.i < b.i;

}



int main(){

	int n, m;

	cin >> n >> m;

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

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

		a[i].i = i;

	}

	sort(a+1,a+1+m,cmp);

//	for(int i = 1; i <= m; i++)

//		printf("%d %d\n",a[i].y,a[i].p);	

	int x = 1, y = 1;

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

		if(a[i].y > x){

			x = a[i].y;

			y = 1;	

		}

		a[i].j = y++;

//		printf("%06d%06d\n",x,y++);

	}

	sort(a+1,a+1+m,cmp1);

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

		printf("%06d%06d\n",a[i].y,a[i].j);

	return 0;

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

#include <algorithm>

#include <cstring>

#include <cstdio>

#include <vector>

#include <queue>

#include <stack>

#include <cstdlib>

#include <iomanip>

#include <cmath>

#include <cassert>

#include <ctime>

#include <cstdlib>

#include <map>

#include <set>

using namespace std;

#pragma comment(linker, "/stck:1024000000,1024000000")

#define lowbit(x) (x&(-x))

#define max(x,y) (x>=y?x:y)

#define min(x,y) (x<=y?x:y)

//#define MAX 100000000000000000

#define MOD 1000000007

#define pi acos(-1.0)

#define ei exp(1)

#define PI 3.1415926535897932384626433832

#define ios() ios::sync_with_stdio(true)

#define INF (1<<31)-1;

#define mem(a) (memset(a,0,sizeof(a)))

struct P{

    int x,y;

}H[200000];

vector<int>G[200000];

int POS(int k,int value){

    int mid;

    int left = 0;

    int len = G[k].size();

    int right = len - 1;

    //cout<<" "<<k<<"A"<<value<<endl;

    while(left <= right){

 

        // 确保中点靠近区间的起点

        mid = left + (right-left)/2;

        //cout<<mid<<endl;

        //cout<<"mid= "<<mid<<" "<<left<<" "<<right<<endl;

        // 如果找到则返回

        if(G[k][mid] == value) return mid;

        // 将中点赋给终点

        else if(G[k][mid] > value) right = mid;

        // 将中点加一赋给起点

        else left = mid + 1;

    }

    return -1;

}

set<int>::iterator it;

int main()

{

    set<int>s;

    int N,M;

    int x,y;

    cin>>N>>M;

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

        cin>>x>>y;

        H[i].x = x;

        H[i].y = y;

        G[x].push_back(y);

        s.insert(x);

    }

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

        sort(G[i].begin(),G[i].end());

    }

 

 

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

        cout<<setw(6)<<setfill('0')<<H[i].x;

        cout<<setw(6)<<setfill('0')<<POS(H[i].x,H[i].y)+1<<endl;

    }

    return 0;

}

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

using namespace std;



struct T{

	int y, p, i, j;

}a[100005];



bool cmp(T a, T b){

	if(a.y == b.y)

		return a.p < b.p;

	return a.y < b.y;

}



bool cmp1(T a, T b){

	return a.i < b.i;

}



int main(){

	int n, m;

	cin >> n >> m;

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

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

		a[i].i = i;

	}

	sort(a+1,a+1+m,cmp);

//	for(int i = 1; i <= m; i++)

//		printf("%d %d\n",a[i].y,a[i].p);	

	int x = 1, y = 1;

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

		if(a[i].y > x){

			x = a[i].y;

			y = 1;	

		}

		a[i].j = y++;

//		printf("%06d%06d\n",x,y++);

	}

	sort(a+1,a+1+m,cmp1);

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

		printf("%06d%06d\n",a[i].y,a[i].j);

	return 0;

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

#include<algorithm>

#include<stdio.h>

#include<string.h>

#include<vector>

using namespace std;

typedef  long long ll;

int N,M,P,Y;

const int maxm=(int)1e5+5;

struct city{

int p;

int y;

int i;

int flag;

city(){

    flag = 0;

}

};

city C[maxm];

int tot;

bool cmp1(city city1,city city2){

    return city1.p<city2.p ||(city1.p==city2.p&&city1.y<city2.y);

}

bool cmp2(city city1,city city2){

    return city1.i<city2.i;

}

int main(){

    scanf("%d%d",&N,&M);

    tot=0;

    memset(C,0,sizeof(C));

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

        struct city tmp;

        scanf("%d%d",&P,&Y);

        tmp.p=P;tmp.y=Y;tmp.i=i;

        C[tot]=tmp;

        tot++;

    }

    sort(C,C + M,cmp1);

    C[0].flag=1;

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

        if(C[i].p==C[i-1].p)C[i].flag=C[i-1].flag+1;

        else C[i].flag=1;

    }

     sort(C,C + M,cmp2);

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

        printf("%06d%06d\n",C[i].p,C[i].flag);

     }

    //for(int i=0;i<M;i++)

      //  cout<<"p:"<<C[i].p<<"y:"<<C[i].y<<"flag:"<<C[i].flag<<"i:"<<C[i].i<<endl;

    return 0;

}


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

using namespace std;



struct T{

	int y, p, i, j;

}a[100005];



bool cmp(T a, T b){

	if(a.y == b.y)

		return a.p < b.p;

	return a.y < b.y;

}



bool cmp1(T a, T b){

	return a.i < b.i;

}



int main(){

	int n, m;

	cin >> n >> m;

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

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

		a[i].i = i;

	}

	sort(a+1,a+1+m,cmp);

//	for(int i = 1; i <= m; i++)

//		printf("%d %d\n",a[i].y,a[i].p);	

	int x = 1, y = 1;

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

		if(a[i].y > x){

			x = a[i].y;

			y = 1;	

		}

		a[i].j = y++;

//		printf("%06d%06d\n",x,y++);

	}

	sort(a+1,a+1+m,cmp1);

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

		printf("%06d%06d\n",a[i].y,a[i].j);

	return 0;

}