description: <image>
  
  William has two numbers a and b initially both equal to zero. William mastered performing three different operations with them quickly. Before performing each operation some positive integer k is picked, which is then used to perform one of the following operations: (note, that for each operation you can choose a new positive integer k)
  
    1. add number k to both a and b, or 
    2. add number k to a and subtract k from b, or 
    3. add number k to b and subtract k from a. 
  
  
  
  Note that after performing operations, numbers a and b may become negative as well.
  
  William wants to find out the minimal number of operations he would have to perform to make a equal to his favorite number c and b equal to his second favorite number d.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
  
  The only line of each test case contains two integers c and d (0 ≤ c, d ≤ 10^9), which are William's favorite numbers and which he wants a and b to be transformed into.
  
  Output
  
  For each test case output a single number, which is the minimal number of operations which William would have to perform to make a equal to c and b equal to d, or -1 if it is impossible to achieve this using the described operations.
  
  Example
  
  Input
  
  
  6
  1 2
  3 5
  5 3
  6 6
  8 0
  0 0
  
  
  Output
  
  
  -1
  2
  2
  1
  2
  0
  
  Note
  
  Let us demonstrate one of the suboptimal ways of getting a pair (3, 5):
  
    * Using an operation of the first type with k=1, the current pair would be equal to (1, 1). 
    * Using an operation of the third type with k=8, the current pair would be equal to (-7, 9). 
    * Using an operation of the second type with k=7, the current pair would be equal to (0, 2). 
    * Using an operation of the first type with k=3, the current pair would be equal to (3, 5). 
solution: // package deltrix;
  
  
  import java.io.ByteArrayInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.*;
  
  public class A {
  	static FastReader s;
  	static String INPUT = "6\n"
  			+ "1 2\n"
  			+ "3 5\n"
  			+ "5 3\n"
  			+ "6 6\n"
  			+ "8 0\n"
  			+ "0 0\n"
  			+ "";
  
  	public static void main(String[] args) {
  		long time = System.currentTimeMillis();
  		boolean oj = System.getProperty("ONLINE_JUDGE") != null;
  		s = new FastReader(oj);
  		int t = s.nextInt();
  		while(t-- > 0) {
  			int a= s.nextInt();
  			int b = s.nextInt();
  			if (b < a) {
  				int temp = a;
  				a = b;
  				b = temp;
  			}
  			if ((b - a) % 2 != 0) {
  				System.out.println(-1);
  			} else {
  				if (a == 0 && b == 0) {
  					System.out.println(0);
  				} else if (b == a) {
  					System.out.println(1);
  				} else {
  					System.out.println(2);
  				}
  			}
  		}
  		if (!oj) {
  			System.out.println(Arrays.deepToString(new Object[] { System.currentTimeMillis() - time + " ms" }));
  		}
  	}
  
  	private static class UnionFindDisjointSet {
  		int[] parent;
  		int[] size;
  		int n;
  		int size1;
  
  		public UnionFindDisjointSet(int n) {
  			this.n = n;
  			this.parent = new int[n];
  			this.size = new int[n];
  			for (int i = 0; i < n; i++) {
  				parent[i] = i;
  			}
  
  			for (int i = 0; i < n; i++) {
  				size[i] = 1;
  			}
  
  			this.size1 = n;
  		}
  
  		private int numDisjointSets() {
  			System.out.println(size1);
  			return size1;
  		}
  
  		private boolean find(int a, int b) {
  			int rootA = root(a);
  			int rootB = root(b);
  			if (rootA == rootB) {
  				return true;
  			}
  			return false;
  		}
  
  		private int root(int b) {
  			while (parent[b] != b) {
  				parent[b] = parent[parent[b]];
  				b = parent[b];
  			}
  			return b;
  		}
  
  		private void union(int a, int b) {
  			int rootA = root(a);
  			int rootB = root(b);
  			if (rootA == rootB) {
  				return;
  			}
  
  			if (size[rootA] < size[rootB]) {
  				parent[rootA] = parent[rootB];
  				size[rootB] += size[rootA];
  			} else {
  				parent[rootB] = parent[rootA];
  				size[rootA] += size[rootB];
  			}
  			size1--;
  			System.out.println(Arrays.toString(parent));
  		}
  	}
  
  	static ArrayList<Long> printDivisors(long n) {
  		// Note that this loop runs till square root
  		ArrayList<Long> list = new ArrayList<>();
  		for (long i = 1; i <= Math.sqrt(n); i++) {
  			if (n % i == 0) {
  				if (n / i == i) {
  					list.add(i);
  				} else {
  					list.add(i);
  					list.add(n / i);
  				}
  			}
  		}
  		return list;
  	}
  
  	//    GCD - Using Euclid theorem.
  	private static long gcd(long a, long b) {
  		if (b == 0) {
  			return a;
  		}
  
  		return gcd(b, a % b);
  	}
  
  	//    Extended euclidean algorithm
  	//    Used to solve equations of the form ax + by = gcd(a,b)
  	//    return array [d, a, b] such that d = gcd(p, q), ap + bq = d
  	static long[] extendedEuclidean(long p, long q) {
  		if (q == 0)
  			return new long[] { p, 1, 0 };
  
  		long[] vals = extendedEuclidean(q, p % q);
  		long d = vals[0];
  		long a = vals[2];
  		long b = vals[1] - (p / q) * vals[2];
  		return new long[] { d, a, b };
  	}
  
  	// X ^ y mod p
  	static long power(long x, long y, long p) {
  		long res = 1;
  		x = x % p;
  
  		while (y > 0) {
  			if ((y & 1) == 1)
  				res = (res * x) % p;
  			y = y >> 1;
  			x = (x * x) % p;
  		}
  		return res;
  	}
  
  	// Returns modulo inverse of a
  	// with respect to m using extended
  	// Euclid Algorithm. Refer below post for details:
  	// https://www.geeksforgeeks.org/multiplicative-inverse-under-modulo-m/
  	static long inv(long a, long m) {
  		long m0 = m, t, q;
  		long x0 = 0, x1 = 1;
  
  		if (m == 1)
  			return 0;
  
  		// Apply extended Euclid Algorithm
  		while (a > 1) {
  			q = a / m;
  			t = m;
  			m = a % m;
  			a = t;
  			t = x0;
  			x0 = x1 - q * x0;
  			x1 = t;
  		}
  
  		// Make x1 positive
  		if (x1 < 0)
  			x1 += m0;
  
  		return x1;
  	}
  
  	// k is size of num[] and rem[].
  	// Returns the smallest number
  	// x such that:
  	// x % num[0] = rem[0],
  	// x % num[1] = rem[1],
  	// ..................
  	// x % num[k-2] = rem[k-1]
  	// Assumption: Numbers in num[] are pairwise
  	// coprime (gcd for every pair is 1)
  	static long findMinX(long num[], long rem[], long k) {
  		int prod = 1;
  		for (int i = 0; i < k; i++)
  			prod *= num[i];
  
  		int result = 0;
  		for (int i = 0; i < k; i++) {
  			long pp = prod / num[i];
  			result += rem[i] * inv(pp, num[i]) * pp;
  		}
  
  		return result % prod;
  	}
  
  	//  Binary search
  	private static int binarySearch(int[] arr, int ele) {
  		int low = 0;
  		int high = arr.length - 1;
  		while (low <= high) {
  			int mid = (low + high) / 2;
  			if (arr[mid] == ele) {
  				return mid;
  			} else if (ele < arr[mid]) {
  				high = mid - 1;
  			} else {
  				low = mid + 1;
  			}
  		}
  		return -1;
  	}
  
  	//    First occurence using binary search
  	private static int binarySearchFirstOccurence(int[] arr, int ele) {
  		int low = 0;
  		int high = arr.length - 1;
  		int ans = -1;
  		while (low <= high) {
  			int mid = (low + high) / 2;
  			if (arr[mid] == ele) {
  				ans = mid;
  				high = mid - 1;
  			} else if (ele < arr[mid]) {
  				high = mid - 1;
  			} else {
  				low = mid + 1;
  			}
  		}
  		return ans;
  	}
  
  	//    Last occurenece using binary search
  	private static int binarySearchLastOccurence(int[] arr, int ele) {
  		int low = 0;
  		int high = arr.length - 1;
  		int ans = -1;
  		while (low <= high) {
  			int mid = (low + high) / 2;
  			if (arr[mid] == ele) {
  				ans = mid;
  				low = mid + 1;
  			} else if (ele < arr[mid]) {
  				high = mid - 1;
  			} else {
  				low = mid + 1;
  			}
  		}
  		return ans;
  	}
  
  	// Merge sort
  	static void merge(int arr[], int l, int m, int r) {
  		int n1 = m - l + 1;
  		int n2 = r - m;
  		int L[] = new int[n1];
  		int R[] = new int[n2];
  		for (int i = 0; i < n1; ++i)
  			L[i] = arr[l + i];
  		for (int j = 0; j < n2; ++j)
  			R[j] = arr[m + 1 + j];
  		int i = 0, j = 0;
  		int k = l;
  		while (i < n1 && j < n2) {
  			if (L[i] <= R[j]) {
  				arr[k] = L[i];
  				i++;
  			} else {
  				arr[k] = R[j];
  				j++;
  			}
  			k++;
  		}
  
  		while (i < n1) {
  			arr[k] = L[i];
  			i++;
  			k++;
  		}
  
  		while (j < n2) {
  			arr[k] = R[j];
  			j++;
  			k++;
  		}
  	}
  
  	static void sort(int arr[], int l, int r) {
  		if (l < r) {
  			int m = (l + r) / 2;
  			sort(arr, l, m);
  			sort(arr, m + 1, r);
  			merge(arr, l, m, r);
  		}
  	}
  
  	static void sort(int[] arr) {
  		sort(arr, 0, arr.length - 1);
  	}
  
  	private static class FastReader {
  		InputStream is;
  
  		public FastReader(boolean onlineJudge) {
  			is = onlineJudge ? System.in : new ByteArrayInputStream(INPUT.getBytes());
  		}
  
  		byte[] inbuf = new byte[1024];
  		public int lenbuf = 0, ptrbuf = 0;
  
  		int readByte() {
  			if (lenbuf == -1)
  				throw new InputMismatchException();
  			if (ptrbuf >= lenbuf) {
  				ptrbuf = 0;
  				try {
  					lenbuf = is.read(inbuf);
  				} catch (IOException e) {
  					throw new InputMismatchException();
  				}
  				if (lenbuf <= 0)
  					return -1;
  			}
  			return inbuf[ptrbuf++];
  		}
  
  		boolean isSpaceChar(int c) {
  			return !(c >= 33 && c <= 126);
  		}
  
  		int skip() {
  			int b;
  			while ((b = readByte()) != -1 && isSpaceChar(b))
  				;
  			return b;
  		}
  
  		double nextDouble() {
  			return Double.parseDouble(next());
  		}
  
  		char nextChar() {
  			return (char) skip();
  		}
  
  		String next() {
  			int b = skip();
  			StringBuilder sb = new StringBuilder();
  			while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
  				sb.appendCodePoint(b);
  				b = readByte();
  			}
  			return sb.toString();
  		}
  
  		String nextLine() {
  			int b = skip();
  			StringBuilder sb = new StringBuilder();
  			while ((!isSpaceChar(b) || b == ' ')) { // when nextLine, (isSpaceChar(b) && b != ' ')
  				sb.appendCodePoint(b);
  				b = readByte();
  			}
  			return sb.toString();
  		}
  
  		char[] next(int n) {
  			char[] buf = new char[n];
  			int b = skip(), p = 0;
  			while (p < n && !(isSpaceChar(b))) {
  				buf[p++] = (char) b;
  				b = readByte();
  			}
  			return n == p ? buf : Arrays.copyOf(buf, p);
  		}
  
  		int nextInt() {
  			int num = 0, b;
  			boolean minus = false;
  			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
  				;
  			if (b == '-') {
  				minus = true;
  				b = readByte();
  			}
  
  			while (true) {
  				if (b >= '0' && b <= '9') {
  					num = num * 10 + (b - '0');
  				} else {
  					return minus ? -num : num;
  				}
  				b = readByte();
  			}
  		}
  
  		long nextLong() {
  			long num = 0;
  			int b;
  			boolean minus = false;
  			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
  				;
  			if (b == '-') {
  				minus = true;
  				b = readByte();
  			}
  
  			while (true) {
  				if (b >= '0' && b <= '9') {
  					num = num * 10 + (b - '0');
  				} else {
  					return minus ? -num : num;
  				}
  				b = readByte();
  			}
  		}
  
  		char[][] nextMatrix(int n, int m) {
  			char[][] map = new char[n][];
  			for (int i = 0; i < n; i++)
  				map[i] = next(m);
  			return map;
  		}
  
  		int[] nextIntArray(int n) {
  			int[] a = new int[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextInt();
  			return a;
  		}
  
  		long[] nextLongArray(int n) {
  			long[] a = new long[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextLong();
  			return a;
  		}
  
  		int[][] next2DInt(int n, int m) {
  			int[][] arr = new int[n][];
  			for (int i = 0; i < n; i++) {
  				arr[i] = nextIntArray(m);
  			}
  			return arr;
  		}
  
  		long[][] next2DLong(int n, int m) {
  			long[][] arr = new long[n][];
  			for (int i = 0; i < n; i++) {
  				arr[i] = nextLongArray(m);
  			}
  			return arr;
  		}
  
  		int[] shuffle(int[] arr) {
  			Random r = new Random();
  			for (int i = 1, j; i < arr.length; i++) {
  				j = r.nextInt(i);
  				arr[i] = arr[i] ^ arr[j];
  				arr[j] = arr[i] ^ arr[j];
  				arr[i] = arr[i] ^ arr[j];
  			}
  			return arr;
  		}
  
  		int[] uniq(int[] arr) {
  			Arrays.sort(arr);
  			int[] rv = new int[arr.length];
  			int pos = 0;
  			rv[pos++] = arr[0];
  			for (int i = 1; i < arr.length; i++) {
  				if (arr[i] != arr[i - 1]) {
  					rv[pos++] = arr[i];
  				}
  			}
  			return Arrays.copyOf(rv, pos);
  		}
  	}
  }
  
  