10
4 2
7 4
2 6
2 5
4 8
10 3
2 9
9 1
5 10
 10
5 10
7 8
8 3
2 6
3 2
9 7
4 5
10 1
6 4
 4
4 1
4 3
4 2
 3
3 1
1 2
 9
1 2
1 3
1 4
1 5
1 6
6 7
6 8
8 9
 5
1 5
2 3
2 4
1 2
 8
6 1
4 7
4 8
8 5
7 6
4 3
4 2
 7
5 6
5 7
5 1
7 4
6 3
3 2
 3
1 3
3 2
 2
1 2
 5
5 4
4 3
3 1
5 2
 6
1 6
3 1
6 4
5 3
2 5
 11
8 9
2 7
1 11
3 2
9 1
8 5
8 6
5 4
4 10
8 3
 11
11 9
6 7
7 1
8 11
5 6
3 5
9 3
10 8
2 4
4 10
 12
12 6
6 7
8 11
4 8
10 4
12 3
2 10
6 2
12 9
4 1
9 5

-1
 9
 1
 1
 3
 3
 -1
 -1
 1
 1
 1
 5
 1
 5
 -1


import java.util.*;

public class PC {
    static int[] depth;
    static int[] lastCommonParent;
    static ArrayList<Integer> leaves;
    public static void main (String args[]) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        HashMap<Integer, ArrayList<Integer>> edges = new HashMap<>();
        for (int i = 0 ; i < n-1; i++){
            int a = scanner.nextInt();
            int b =  scanner.nextInt();
            addEdges(edges, a, b);
            addEdges(edges,b,a);
        }

        boolean[] isVisited =  new boolean[n+1];
        long min = Integer.MAX_VALUE;
        int numLeaves=  0;
        for (int i = 1 ; i <= n; i++){
            if (edges.get(i).size() == 1) {
                numLeaves++;
                depth =  new int[n+1];
                lastCommonParent =  new int[n+1];
                leaves =  new ArrayList<>();
                dfs(edges,i,isVisited);
                for (int k = 0 ; k <leaves.size(); k++){
                    for (int l = 0 ; l <leaves.size(); l++){
                        if (k == l) continue;
                        int leafK = leaves.get(k);
                        int leafL = leaves.get(l);
                        if (depth[leafL] == depth[leafK] && lastCommonParent[leafK] == lastCommonParent[leafL]){
                            min =  Math.min(min, depth[leafK] - depth[lastCommonParent[leafK]]);
                        }
                    }
                }
            }



        }
        if (numLeaves == 2){
            if (n%2 == 1) System.out.println(n/2);
            else System.out.println(n-1);
        }else if (min == Integer.MAX_VALUE) System.out.println(-1);
        else System.out.println(min+1);

    }

    private static void dfs(HashMap<Integer, ArrayList<Integer>> edges,int start,  boolean[] isVisted) {
        Stack<Integer> stack =  new Stack<>();
        int latestCommon=  start;
        depth[start] = 0;
        stack.push(start);
        while (!stack.isEmpty()){
            int node  = stack.pop();
            isVisted[node] = true;
            ArrayList<Integer> neighbors = edges.get(node);
            int count = 0;
            for (Integer neighbor : neighbors){
                if (!isVisted[neighbor]){
                    depth[neighbor] = depth[node] +1;
                    stack.push(neighbor);
                    count++;
                }
            }
            if (count > 1) latestCommon = node;
            else if (count == 0) leaves.add(node);
            lastCommonParent[node] = latestCommon;
        }

    }

    private static void bfs(HashMap<Integer, ArrayList<Integer>> edges, int start, boolean[] isVisited) {
        LinkedList<Integer> queue =  new LinkedList<>();
        queue.push(start);
        while (!queue.isEmpty()){
            int node  = queue.pop();
            isVisited[node] = true;
            ArrayList<Integer> neighbors = edges.get(node);
            for (Integer neighbor : neighbors){
                if (!isVisited[neighbor]){
                    queue.add(neighbor);
                }
            }
        }
    }

//    private static void dfs(HashMap<Integer, ArrayList<Integer>> edges, int start, boolean[] isVisited) {
//        Stack<Integer> stack =  new Stack<>();
//        stack.push(start);
//        while (!stack.isEmpty()){
//            int node  = stack.pop();
//            isVisited[node] = true;
//            ArrayList<Integer> neighbors = edges.get(node);
//            for (Integer neighbor : neighbors){
//                if (!isVisited[neighbor]){
//                    stack.push(neighbor);
//                }
//            }
//        }
//    }
    private static void addEdges(HashMap<Integer, ArrayList<Integer>> edges, int a, int b) {
        if (edges.containsKey(a)){
            edges.get(a).add(b);
        }else{
            ArrayList<Integer> temp =  new ArrayList<>();
            temp.add(b);
            edges.put(a,temp);
        }
    }
}
