import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class ehab_mex {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		
		cf_em.init(System.in);
		int n=cf_em.nextInt();
		
		emg g=new emg(n);
		
//		HashMap<int[],Integer> hm=new HashMap<int[],Integer>();
		
		int[][] ans=new int[n-1][3];
		
		int[] degree=new int[n];
		
		for(int x=0;x<n-1;x++) {
			int u=cf_em.nextInt();
			int v=cf_em.nextInt();
			u--;
			v--;
			degree[u]++;
			degree[v]++;
			
//			int[] tmp=new int[2];
//			tmp[0]=u;
//			tmp[1]=v;
//			hm.put(tmp,-2);
			
			ans[x][0]=u;
			ans[x][1]=v;
			ans[x][2]=-2;
			
			g.add_edge(u, v);
		}
		
		int ind=-2;
		
		for(int r=0;r<n;r++) {
			if(degree[r]>=3) {
				ind=r;
			}
		}
		
		if(ind==-2) {
			for(int p=0;p<n-1;p++) {
				System.out.println(p);
			}
		}
		else {
			int ctr=0;
			for(int r=0;r<n-1;r++) {
				if(ind==r) {
					ans[r][2]=ctr;
					ctr++;
				}
			}
			
			for(int q=0;q<n-1;q++) {
				if(ans[q][2]==-2) {
					ans[q][2]=ctr;
					ctr++;
				}
			}
			for(int e=0;e<n-1;e++) {
				System.out.println(ans[e][2]);
			}
		}
		
////		HashMap<int[],Integer> arr=new HashMap<int[],Integer>();
//		HashMap<Integer,HashMap<Integer,Integer>> arr=new HashMap<Integer,HashMap<Integer,Integer>>();
//		
//		HashMap<Integer,Integer> extra=new HashMap<Integer,Integer>();
//		
//		arr=g.bfs();
//		
//		for(int p=0;p<n-1;p++) {
//			int[] ch=new int[2];
//			ch[0]=Math.min(ans[p][0], ans[p][1]);
//			ch[1]=Math.max(ans[p][0], ans[p][1]);
////			System.out.print(ch[0]+" "+ch[1]+" ");
//			extra=arr.get(ch[0]);
//			int num=extra.get(ch[1]);
//			System.out.println(num);
//		}
		
	}

}

class cf_ed{
	int u;
	int v;
	int val;
	
	cf_ed(int a,int b,int c){
		u=a;
		v=b;
		val=c;
	}
}

class emg{
    int n;
    ArrayList<ArrayList<Integer>> adj;
    
    emg(int V){
        n=V;
        adj=new ArrayList<ArrayList<Integer>>();
        
        for(int h=0;h<n;h++){
            adj.add(new ArrayList<Integer>());
        }
    }
    
    void add_edge(int a,int b){
        adj.get(a).add(b);
        adj.get(b).add(a);
    }

    HashMap<Integer,HashMap<Integer,Integer>> bfs() {
    	
    	int[] assign=new int[n-1];
    	
    	for(int w=0;w<n-1;w++) {
    		if(w==n-2 && n-2>=2) {
    			assign[w]=2;
    		}
    		else if(w>=2) {
    			assign[w]=w+1;
    		}
    		else {
    			assign[w]=w;
    		}
    	}
    	
    	int[] dist=new int[n];
    	    	
    	dist[0]=1;
    	
    	Queue<Integer> q=new LinkedList<Integer>();
    	
    	q.add(0);
    	
    	int ind=0;
    	
    	HashMap<Integer,Integer> extra=new HashMap<Integer,Integer>();
    	
    	HashMap<Integer,HashMap<Integer,Integer>> hm=new HashMap<Integer,HashMap<Integer,Integer>>();
    	
    	int[][] ans=new int[n-1][3];
    	
    	while(!q.isEmpty()) {
    		int u=q.poll();
    		
    		for(int e=0;e<adj.get(u).size();e++) {
    			int v=adj.get(u).get(e);
    			
    			if(dist[v]==0) {
    				dist[v]=1;
    				int[] tmp=new int[2];
    				tmp[0]=Math.min(u, v);
    				tmp[1]=Math.max(u, v);
//    				System.out.println(tmp[0]+" "+tmp[1]+" "+assign[ind]);
    				extra.put(tmp[1],assign[ind]);
    				hm.put(tmp[0], extra);
    				ind++;
    				
    				q.add(v);
    			}
    			
    		}
    	}
    	
    	return hm;
    	
    }
    
}


/** Class for buffered reading int and double values */
class cf_em {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	/** call this method to initialize reader for InputStream */
	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	/** get next word */
	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			// TODO add check for eof if necessary
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

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

	static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	
	static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
}



