//package kg.my_algorithms.Codeforces;

import java.io.*;
import java.util.*;

/*


 */
public class Solution {
    private static final Map<Pair,Integer> mapOfAssignedCompanies = new HashMap<>();
    public static void main(String[] args) throws IOException {
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
        FastReader fr = new FastReader();
        StringBuilder sb = new StringBuilder();
        int totalNumberOfCities = fr.nextInt();
        int maximumBadCities = fr.nextInt();
        List<Pair> listOfEdges = new ArrayList<>();
        List<List<Integer>> tree = new ArrayList<>();
        for(int i=0;i<totalNumberOfCities;i++) tree.add(new ArrayList<>());
        for(int i=0;i<totalNumberOfCities-1;i++){
            int city1 = fr.nextInt()-1;
            int city2 = fr.nextInt()-1;
            listOfEdges.add(new Pair(city1,city2));
            tree.get(city1).add(city2);
            tree.get(city2).add(city1);
        }
        int[] numberOfChildren = new int[totalNumberOfCities];
        numberOfChildren[0] = tree.get(0).size();
        for(int i=1;i<totalNumberOfCities;i++) numberOfChildren[i] = tree.get(i).size()-1;
        int lo=1,hi=totalNumberOfCities-1;
        while(lo<=hi){
            int m = (lo+hi)>>1;
            if(canCityHaveMCompanies(numberOfChildren,maximumBadCities,m)) hi=m-1;
            else lo=m+1;
        }
        int companies = hi+1;
        assignCompanies(tree,companies,0,-1,-1);
        sb.append(companies).append("\n");
        for(Pair pair: listOfEdges){
            sb.append(mapOfAssignedCompanies.get(pair)).append(" ");
        }
        output.write(sb.toString());
        output.flush();
    }
    private static boolean canCityHaveMCompanies(int[] numberOfChildren, int maximumBadCities, int m){
        int badCities = (numberOfChildren[0]>m)?1:0;
        for(int i=1;i<numberOfChildren.length;i++) if(numberOfChildren[i]>m-1) badCities++;
        return badCities<=maximumBadCities;
    }
    private static void assignCompanies(List<List<Integer>> tree, int companies, int node,
                                        int prevCompany, int parent){
        if(tree.get(node).size()>companies){
            for(int child: tree.get(node)){
                if(parent==child) continue;
                mapOfAssignedCompanies.put(new Pair(node,child),1);
                assignCompanies(tree,companies,child,1,node);
            }
        }
        else{
            int company = 1;
            for(int child: tree.get(node)){
                if(child==parent) continue;
                if(company==prevCompany) company++;
                mapOfAssignedCompanies.put(new Pair(node,child),company);
                assignCompanies(tree,companies,child,company,node);
                company++;
            }
        }
    }
}
class Pair{
    int u;
    int v;

    public Pair(int u, int v) {
        this.u = u;
        this.v = v;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Pair)) return false;
        Pair pair = (Pair) o;
        return Math.min(u,v)==Math.min(pair.u,pair.v) && Math.max(u,v)==Math.max(pair.u,pair.v);
    }

    @Override
    public int hashCode() {
        long uu = Math.min(this.u, this.v);
        long vv = Math.max(this.u, this.v);
        return (int)((uu*3881 + vv*998244353)%1000_000_007);
    }
}

























//Fast Input
class FastReader {
    BufferedReader br;
    StringTokenizer st;

    public FastReader()
    {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() { return Integer.parseInt(next()); }

    long nextLong() { return Long.parseLong(next()); }

    double nextDouble()
    {
        return Double.parseDouble(next());
    }

    String nextLine()
    {
        String str = "";
        try {
            if(st.hasMoreTokens()){
                str = st.nextToken("\n");
            }
            else{
                str = br.readLine();
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}