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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class TreeFolding {
    
    int INF = (int) 1e9;
    int N = (int) 2e5 + 5;
    
    int n;
    int[][] G;
    
    int[] d = new int[N], par = new int[N];
    
    int root;
    int[] dep = new int[N];
    
    void solve() {
        n = in.nextInt();
        int[] fr = new int[n - 1], to = new int[n - 1];
        for (int i = 0; i < n - 1; i++) {
            fr[i] = in.nextInt() - 1;
            to[i] = in.nextInt() - 1;
        }
        G = build_graph(n, fr, to);
        
        root = findMidOfDiameter();
        
        if (!fold(root, -1)) {
            out.println(-1);
            return;
        }
        
        int ans = dep[root] - 1;
        while (ans % 2 == 0) ans /= 2;
        out.println(ans);
    }
    
    boolean fold(int u, int p) {
        Set<Integer> set = new HashSet<>();
        for (int v : G[u]) {
            if (v != p) {
                if (!fold(v, u)) return false;
                set.add(dep[v]);
            }
        }
        if (set.size() > 2) return false;
        if (set.size() > 1 && u != root) return false;
        dep[u] = 1;
        set.forEach(i -> dep[u] += i);
        return true;
    }
    
    int findMidOfDiameter() {
        Arrays.fill(d, INF);
        d[0] = 0;
        dfs(0, -1);
        
        int v = 0;
        for (int i = 1; i < n; i++) if (d[i] > d[v]) v = i;
        
        Arrays.fill(d, INF);
        Arrays.fill(par, -1);
        d[v] = 0;
        dfs2(v, -1);
        
        int w = v;
        for (int i = 0; i < n; i++) if (d[i] > d[w]) w = i;
        
        int mid = w;
        for (int i = 0; i < d[w] / 2; i++) mid = par[mid];
        return mid;
    }
    
    void dfs(int u, int p) {
        for (int v : G[u]) {
            if (v != p) {
                d[v] = d[u] + 1;
                dfs(v, u);
            }
        }
    }
    
    void dfs2(int u, int p) {
        for (int v : G[u]) {
            if (v != p) {
                d[v] = d[u] + 1;
                par[v] = u;
                dfs2(v, u);
            }
        }
    }
    
    int[][] build_graph(int n, int[] from, int[] to) {
        int[][] G = new int[n][];
        int[] cnt = new int[n];
        for (int i = 0; i < from.length; i++) {
            cnt[from[i]]++;
            cnt[to[i]]++;
        }
        for (int i = 0; i < n; i++) G[i] = new int[cnt[i]];
        for (int i = 0; i < from.length; i++) {
            G[from[i]][--cnt[from[i]]] = to[i];
            G[to[i]][--cnt[to[i]]] = from[i];
        }
        return G;
    }
    
    static class Path {
        int top, len;
        
        public Path(int top, int len) {
            this.top = top;
            this.len = len;
        }
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new TreeFolding().solve();
        out.close();
    }
    
    static FastScanner in;
    static PrintWriter out;
    
    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;
        
        public FastScanner(BufferedReader in) {
            this.in = in;
        }
        
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        
        public long nextLong() {
            return Long.parseLong(nextToken());
        }
        
        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
