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.awt.*;
import java.awt.event.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

public class E {
	static BufferedReader br;
	static StringTokenizer st;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		//int qq = 1;
		int qq = Integer.MAX_VALUE;
		//int qq = readInt();
		for(int casenum = 1; casenum <= qq; casenum++) {
			int n = readInt();
			Set<Integer>[] edges = new Set[n];
			for(int i = 0; i < n; i++) {
				edges[i] = new HashSet<Integer>();
			}
			for(int i = 1; i < n; i++) {
				int a = readInt()-1;
				int b = readInt()-1;
				edges[a].add(b);
				edges[b].add(a);
			}
			Map<Integer, Map<Integer, Integer>> existent = new HashMap<Integer, Map<Integer, Integer>>();
			for(int i = 0; i < n; i++) {
				if(edges[i].size() != 1) continue;
				int current = i;
				int length = 0;
				int parent = -1;
				while(true) {
					while(true) {
						if(edges[current].size() > 2) {
							break;
						}
						if(edges[current].size() == 1 && parent != -1) {
							break;
						}
						for(int out: edges[current]) {
							if(out != parent){
								parent = current;
								current = out;
								length++;
								break;
							}
						}
					}
					if(edges[current].size() == 1) {
						break;
					}
					if(!existent.containsKey(current)) {
						existent.put(current, new HashMap<Integer, Integer>());
					}
					Map<Integer, Integer> distanceToVertex = existent.get(current);
					if(!distanceToVertex.containsKey(length)) {
						distanceToVertex.put(length, parent);
						break;
					}
					else {
						kill(edges, distanceToVertex.get(length), current);
						distanceToVertex.remove(length);
					}
				}
			}
			int numV = 0;
			boolean good = true;
			for(int i = 0; i < n; i++) {
				if(edges[i].size() > 0) {
					numV++;
				}
				if(edges[i].size() > 2) {
					good = false;
				}
			}
			if(!good) {
				pw.println(-1);
				continue;
			}
			numV--;
			while(numV%2 == 0) {
				numV /= 2;
			}
			pw.println(numV);
		}
		pw.close();
	}

	public static void kill(Set<Integer>[] edges, int curr, int stop) {
		edges[stop].remove(curr);
		LinkedList<Integer> q = new LinkedList<Integer>();
		q.add(curr);
		while(!q.isEmpty()) {
			curr = q.removeFirst();
			for(int out: edges[curr]) {
				if(out != stop) {
					q.add(out);
				}
			}
			edges[curr] = new HashSet<Integer>();
		}
	}
	
	public static void exitImmediately() {
		pw.close();
		System.exit(0);
	}

	public static int readInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public static double readDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public static long readLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public static String nextLine() throws IOException {
		st = null;
		if(!br.ready()) {
			exitImmediately();
		}
		return br.readLine();
	}

	public static String nextToken() throws IOException {
		while(st == null || !st.hasMoreTokens()) {
			if(!br.ready()) {
				exitImmediately();
			}
			st = new StringTokenizer(br.readLine());
		}
		return st.nextToken();
	}
}
