Problem:
Score: 300 points

Problem Statement

In Republic of Atcoder, there are N prefectures, and a total of M cities that belong to those prefectures.

City i is established in year Y_i and belongs to Prefecture P_i.

You can assume that there are no multiple cities that are established in the same year.

It is decided to allocate a 12-digit ID number to each city.

If City i is the x-th established city among the cities that belong to Prefecture i, the first six digits of the ID number of City i is P_i, and the last six digits of the ID number is x.

Here, if P_i or x (or both) has less than six digits, zeros are added to the left until it has six digits.

Find the ID numbers for all the cities.

Note that there can be a prefecture with no cities.

Constraints

1 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq P_i \leq N

1 \leq Y_i \leq 10^9

Y_i are all different.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
P_1 Y_1
:
P_M Y_M

Output

Print the ID numbers for all the cities, in ascending order of indices (City 1, City 2, ...).

Sample Input 1

2 3
1 32
2 63
1 12

Sample Output 1

000001000002
000002000001
000001000001

As City 1 is the second established city among the cities that belong to Prefecture 1, its ID number is 000001000002.

As City 2 is the first established city among the cities that belong to Prefecture 2, its ID number is 000002000001.

As City 3 is the first established city among the cities that belong to Prefecture 1, its ID number is 000001000001.

Sample Input 2

2 3
2 55
2 77
2 99

Sample Output 2

000002000001
000002000002
000002000003

Solution in C (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

// pactice
 
#pragma warning(disable:4996)
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wwrite-strings"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#define MAX_NUMBER 100000
#define MAX_STRING 100

	int anBelongPref[MAX_NUMBER];
	int anBelongPrefForSort[MAX_NUMBER];
	int anBirthYear[MAX_NUMBER];
	int anBirthYearForSort[MAX_NUMBER];
	long long anBirthYearWithPref[MAX_NUMBER];
	int anRankInPref[MAX_NUMBER];
	int anStartPos[MAX_NUMBER];
//	int anHavingCityNumber[MAX_NUMBER];
	int compare(const long long *val1, const long long *val2);

int main() {
	char sInput[MAX_STRING+1]=""; 
	char* psInput=NULL;
	int nNumberOfNumber=0;
	int nTargetNumber=0;
	int nBlockNumber=0;
	int i=0;
	int j=0;
	int nCount=0;

	int nPref=0;
	int nCity=0;
	int nTemp=0;
	int nPrev=0;
	int nTempPref=0;
	int nTempCount=0;
	int nTempYear=0;
	long lTemp=0;
	long lTempYear=0;
	long lPrev=0;

	for(i=0;i<MAX_NUMBER;i++){
		anBelongPref[i]=0;
		anBelongPrefForSort[i]=0;
		anBirthYear[i]=0;
		anBirthYearWithPref[i]=0;
		anRankInPref[i]=0;
//		anHavingCityNumber[i]=0;
	}
	// read line 1
	gets(sInput);
	psInput = strtok(sInput," ");
	nPref=atoi(psInput);
	psInput = strtok(NULL," ");
	nCity=atoi(psInput);

	// read line 2 ...
	for (i=0;i<nCity;i++){
		gets(sInput);
		psInput = strtok(sInput," ");
		nTemp=atoi(psInput);
		anBelongPref[i]=nTemp;
//		anHavingCityNumber[nTemp-1]=anHavingCityNumber[nTemp-1]+1;

		psInput = strtok(NULL," ");
		anBirthYear[i]=atoi(psInput);
//		anBirthYearForSort[i]=atoi(psInput);
		anBirthYearWithPref[i]=(long long)(10000000000*nTemp+atoi(psInput));
	}
//    qsort(anBirthYearForSort, nCity, sizeof(int),
    qsort(anBirthYearWithPref, nCity, sizeof(long long),
	(int (*)(const void *, const void *))compare);
	
	for (i=0;i<nCity;i++){
		nTemp=(int)(anBirthYearWithPref[i] / 10000000000);
		if(nTemp>nPrev){
			anStartPos[nTemp-1]=i;
			nPrev=nTemp;
		}
	}


/*	for (i=0;i<nCity;i++){
		nTemp=anBirthYearForSort[i];
		for (j=0;j<nCity;j++){
			if(nTemp==anBirthYear[j]){
				anBelongPrefForSort[i]=anBelongPref[j];
				break;
			}
		}
	}
	for (i=0;i<nCity;i++){
		nTempPref=anBelongPref[i];
		nTempCount=0;
		for (j=0;j<nCity;j++){
			if(nTempPref==anBelongPrefForSort[j]){
				nTempCount++;
				if(anBirthYear[i]==anBirthYearForSort[j]){
					anRankInPref[i]=nTempCount;
					break;
				}
			}
		}
	}*/

	for (i=0;i<nCity;i++){
		nCount=0;
		nTempYear=anBirthYear[i];
		for (j=anStartPos[anBelongPref[i]-1];j<nCity;j++){
			nCount++;
			if(anBirthYearWithPref[j] % 10000000000 == nTempYear){
				break;
			}
		}
		printf("%06d%06d\n",anBelongPref[i],nCount);
	}

	return 0;
}
int compare(const long long *val1, const long long *val2) {
    if ( *val1 < *val2 ) {
        return -1;
    } else if ( *val1 == * val2 ) {
        return 0;
    } else {
        return 1;
    }
}