Problem:
Score : 400 points

Problem Statement

Given is a tree G with N vertices.
The vertices are numbered 1 through N, and the i-th edge connects Vertex a_i and Vertex b_i.

Consider painting the edges in G with some number of colors.
We want to paint them so that, for each vertex, the colors of the edges incident to that vertex are all different.

Among the colorings satisfying the condition above, construct one that uses the minimum number of colors.

Constraints

2 \le N \le 10^5

1 \le a_i \lt b_i \le N

All values in input are integers.

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

Print N lines.

The first line should contain K, the number of colors used.

The (i+1)-th line (1 \le i \le N-1) should contain c_i, the integer representing the color of the i-th edge, where 1 \le c_i \le K must hold.

If there are multiple colorings with the minimum number of colors that satisfy the condition, printing any of them will be accepted.

Sample Input 1

3
1 2
2 3

Sample Output 1

2
1
2

Sample Input 2

8
1 2
2 3
2 4
2 5
4 7
5 6
6 8

Sample Output 2

4
1
2
3
4
1
1
2

Sample Input 3

6
1 2
1 3
1 4
1 5
1 6

Sample Output 3

5
1
2
3
4
5

Solution in Haskell (GHC 7.10.3) (judge verdict: Wrong Answer)

{-# LANGUAGE BangPatterns #-}

module Main where

import Data.Foldable
import Data.Traversable
import qualified Data.HashMap.Strict as HM
import qualified Data.Sequence as S

type Map = HM.HashMap Int

newtype Id = Id
    { unId :: Int
    } deriving (Eq, Show)

newtype Color = Color
    { unColor :: Int
    } deriving (Eq, Show)

data Node = Node
    { nId    :: !Id
    , nNodes :: !(S.Seq Id)
    , nEdges :: !(S.Seq Id)
    } deriving Show

data Edge = Edge
    { eId    :: !Id
    , eVertA :: !Id
    , eVertB :: !Id
    , eColor :: !Color
    } deriving Show

main :: IO ()
main = do
    n    <- read <$> getLine :: IO Int
    iabs <- forM [1..n-1] $ \id -> do
        a:b:_ <- map read . words <$> getLine
        return (Id id, Id a, Id b)
    let !nodes = createNodes $ map Id [1..n]
    let !edges = createEdges iabs
    let !constructedNodes = constructNodes nodes edges
    let !constructedEdges = constructEdges constructedNodes edges
    print $ foldl max 0 $ map (unColor . eColor) $ HM.elems constructedEdges
    forM_ constructedEdges $ \edge -> print $ unColor $ eColor edge

createNodes :: [Id] -> Map Node
createNodes ids = foldl insertNode HM.empty ids
    where
    insertNode :: Map Node -> Id -> Map Node
    insertNode m id = HM.insert (unId id) (newNode id) m

    newNode :: Id -> Node
    newNode id = Node id S.empty S.empty

    n :: Int
    !n = length ids

createEdges :: [(Id, Id, Id)] -> Map Edge
createEdges = foldl insertEdge HM.empty
    where
    insertEdge :: Map Edge -> (Id, Id, Id) -> Map Edge
    insertEdge m (id, a, b) = HM.insert (unId id) (newEdge id a b) m

    newEdge :: Id -> Id -> Id -> Edge
    newEdge id a b = Edge id a b $ Color 0

constructNodes :: Map Node -> Map Edge -> Map Node
constructNodes = foldl connectNodes
    where
    connectNodes :: Map Node -> Edge -> Map Node
    connectNodes nodes edge =
        foldl insertInMap nodes [insertVertA, insertVertB]
        where
        insertInMap :: Map Node -> Node -> Map Node
        insertInMap m node = HM.insert (unId $ nId node) node m

        insertVertA :: Node
        !insertVertA = storeNode vertA (nId vertB) (eId edge)

        insertVertB :: Node
        !insertVertB = storeNode vertB (nId vertA) (eId edge)

        vertA :: Node
        !vertA = extractNode edge eVertA
        
        vertB :: Node
        !vertB = extractNode edge eVertB

        extractNode :: Edge -> (Edge -> Id) -> Node
        extractNode edge vert = nodes HM.! unId (vert edge)
    
    storeNode :: Node -> Id -> Id -> Node
    storeNode node nId eId =
        node { nNodes = nodes S.|> nId, nEdges = edges S.|> eId }
        where
        nodes :: S.Seq Id
        !nodes = nNodes node

        edges :: S.Seq Id
        !edges = nEdges node

constructEdges :: Map Node -> Map Edge -> Map Edge
constructEdges nodes =
    constructOneEdge (Id 0) (Color 0) (nodes HM.! 1)
    where
    constructOneEdge :: Id -> Color -> Node -> Map Edge -> Map Edge
    constructOneEdge prevId prevColor node edges =
        foldl constructNextEdges newEdges nexts
        where
        constructNextEdges m (nextNode, nextEdge, nextColor) =
            constructOneEdge (nId node) nextColor (nodes HM.! unId nextNode) m
        
        nextNodes :: [(Id, Id)]
        nextNodes = filter ((/= prevId) . fst) $ zip (toList $ nNodes node) (toList $ nEdges node)
        
        nextColors :: [Color]
        nextColors = filter (/= prevColor) $ map Color [1..length $ nNodes node]
        
        nexts :: [(Id, Id, Color)]
        !nexts = zip3 (map fst nextNodes) (map snd nextNodes) nextColors
        
        newEdges :: Map Edge
        !newEdges = foldl (\m (node, edge, color) -> HM.insert (unId edge) (newEdge edge color) m) edges nexts
        
        newEdge :: Id -> Color -> Edge
        newEdge edge color = (edges HM.! unId edge) { eColor = color }