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 Rust (1.15.1) (judge verdict: Accepted)

use std::fmt::Debug;
use std::str::FromStr;

#[allow(dead_code)]
#[allow(deprecated)]
fn read_line_from_stdin() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).unwrap();
    buffer.trim_right().to_owned()
}

#[allow(dead_code)]
#[allow(deprecated)]
fn parse_line_to_single<T>() -> T
where
    T: FromStr,
    T::Err: Debug,
{
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).unwrap();
    T::from_str(buffer.trim_right()).unwrap()
}

#[allow(dead_code)]
#[allow(deprecated)]
fn parse_line_to_multiple<T>() -> Vec<T>
where
    T: FromStr,
    T::Err: Debug,
{
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).unwrap();
    buffer
        .trim_right()
        .split_whitespace()
        .flat_map(|s| T::from_str(s))
        .collect()
}

#[allow(unused_macros)]
macro_rules! parse_line {
    [$( $x:tt : $t:ty ),+] => {
        //declare variables
        $( let $x: $t; )+
        {
            use std::str::FromStr;
            // read
            let mut buf = String::new();
            std::io::stdin().read_line(&mut buf).unwrap();
            #[allow(deprecated)]
            let mut splits = buf.trim_right().split_whitespace();
            // assign each variable
            $(
                $x = splits.next().and_then(|s| <$t>::from_str(s).ok()).unwrap();
            )+
            // all strs should be used for assignment
            assert!(splits.next().is_none());
        }
    };
}

use std::collections::HashMap;

#[derive(Debug, Clone, Copy, PartialEq)]
struct City {
    id: usize,
    born_year: usize,
}

fn main() {
    parse_line![prefecture_count: usize, city_count: usize];

    let mut cities_on_prefectures = HashMap::<usize, Vec<City>>::new();

    for i in 1..prefecture_count + 1 {
        cities_on_prefectures.insert(i, vec![]);
    }

    for i in 1..city_count + 1 {
        parse_line![belonging_prefecture: usize, born_year: usize];

        let city = City {
            id: i,
            born_year: born_year,
        };

        cities_on_prefectures
            .get_mut(&belonging_prefecture)
            .unwrap()
            .push(city);
    }

    let mut idstrings = HashMap::<usize, String>::new();

    for i in 1..prefecture_count + 1 {
        if let Some(cities) = cities_on_prefectures.get(&i) {
            let mut cities = cities.to_vec();
            cities.sort_by_key(|c| c.born_year);
            let id_left = to_id_string(i);
            for (index, city) in cities.into_iter().enumerate() {
                let id_right = to_id_string(index + 1);
                let idstring = format!("{}{}", id_left, id_right);
                idstrings.insert(city.id, idstring);
            }
        }
    }

    for i in 1..city_count + 1 {
        println!("{}", idstrings[&i]);
    }
}

fn to_id_string(x: usize) -> String {
    let right = x.to_string();
    let zero_count = 6 - right.len();

    let mut s = String::new();

    for _ in 0..zero_count {
        s.push('0');
    }
    s.push_str(&right);

    s
}