Problem:
Score : 600 points

Problem Statement

We have a tree with N vertices. The vertices are numbered 1 to N, and the i-th edge connects Vertex a_i and Vertex b_i.

Takahashi loves the number 3. He is seeking a permutation p_1, p_2, \ldots , p_N of integers from 1 to N satisfying the following condition:

For every pair of vertices (i, j), if the distance between Vertex i and Vertex j is 3, the sum or product of p_i and p_j is a multiple of 3.

Here the distance between Vertex i and Vertex j is the number of edges contained in the shortest path from Vertex i to Vertex j.

Help Takahashi by finding a permutation that satisfies the condition.

Constraints

2\leq N\leq 2\times 10^5

1\leq a_i, b_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
a_2 b_2
\vdots
a_{N-1} b_{N-1}

Output

If no permutation satisfies the condition, print -1.

Otherwise, print a permutation satisfying the condition, with space in between.
If there are multiple solutions, you can print any of them.

Sample Input 1

5
1 2
1 3
3 4
3 5

Sample Output 1

1 2 5 4 3

The distance between two vertices is 3 for the two pairs (2, 4) and (2, 5).

p_2 + p_4 = 6

p_2\times p_5 = 6

Thus, this permutation satisfies the condition.

Solution in Rust (1.15.1) (judge verdict: Runtime Error)

use std::io;
use std::str::FromStr;
use std::collections::HashSet;

fn input<T:FromStr>() -> T {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.trim().parse().ok().unwrap()
}

fn input_tuple() -> (usize, usize) {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    let vec: Vec<usize> = line.split_whitespace().map(|s| s.parse().unwrap()).collect();
    (vec[0], vec[1])
}

fn dfs(i: usize, pre: usize, edges: &Vec<Vec<usize>>, count: u64, threes: &mut Vec<usize>) {
    if count == 3 {
        threes.push(i);
        return;
    }
    for neighbor in &edges[i] {
        if *neighbor != pre {
            dfs(*neighbor, i, edges, count + 1, threes);
        }
    }
}


fn main() {
    let n: usize = input();
    let mut edges: Vec<Vec<usize>> = Vec::new();
    for _ in 0..n {
        let edge: Vec<usize> = Vec::new();
        edges.push(edge);
    }
    for _ in 0..(n - 1) {
        let (a, b) = input_tuple();
        edges[a - 1].push(b - 1);
        edges[b - 1].push(a - 1);
    }
    // println!("{:?}", edges);
   
    let mut candidates: Vec<u64> = (1u64..(n+1) as u64).collect();
    let mut ans = vec![0u64; n];
    for i in 0..n {
        let mut threes: Vec<usize> = Vec::new();
        dfs(i, i, &edges, 0, &mut threes);
        if ans[i] == 0 {
            ans[i] = candidates.pop().unwrap();
        }        
        // println!("i = {}, threes = {:?}", i, threes);
        for node in &threes {
            // println!("{}, {:?}", node, candidates);
            if *node > i {
                for j in 0..candidates.len() {
                    if (ans[i] as u64 + candidates[j]) % 3 == 0 || (ans[i] as u64 * candidates[j]) % 3 == 0 {
                        ans[*node] = candidates[j];
                        candidates.remove(j);
                        break;
                    }
                }
            }
        }
    }
    for a in ans {
        print!("{} ", a);
    }
    println!();

}