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: import java.util.*;
  
  import java.io.*;
  public class ferrisWheel  {
  	static Scanner sc=new Scanner(System.in);
  	static PrintWriter pw=new PrintWriter(System.out);
      public static int gcd(int a, int b) {
  	   if (b == 0) return a;
  	   return gcd(b, a%b);
  	}
  	
  	static LinkedList<Character> ll1,ll2;
  	public static void main(String[] args) throws IOException, InterruptedException {
  	int t=sc.nextInt();
  	while(t-->0) {
  		int a=sc.nextInt(),b=sc.nextInt();
  		if(Math.abs(a-b)%2==1)
  			pw.println(-1);
  		else if(a==b && a==0)
  			pw.println(0);
  		else if(a==b)
  			pw.println(1);
  		else {
  			pw.println(2);
  		}
  	}
  	
      pw.flush();
  	}
  	static class pair{
  		int x;
  		int y;
  		public pair(int a,int b) {
  			this.x=a;this.y=b;
  		}
  		public void swap(pair p) {
  			pair temp=new pair(p.x, p.y);
  			p.x=this.x;p.y=this.y;
  			this.x=temp.x;this.y=temp.y;
  		}
  		public String toString () {
  			return x+","+y+" ";
  		}
  		
  		public boolean equals(pair p) {
  			if(x==p.x && y==p.y)
  				return true;
  			return false;
  		}
  	}
  	static class PairPoint{
  		pair p1;
  		pair p2;
  		public PairPoint(pair p1,pair p2) {
  			this.p1=p1;
  			this.p2=p2;
  			
  		}
          public boolean inter(pair p) {
          	if((p.x>=p1.x && p.x<=p2.x) && (p.y>=p1.y && p.y<=p2.y))
          		return true;
          	else if((p.x>=p2.x && p.x<=p1.x) && (p.y>=p2.y && p.y<=p1.y))
          		return true;
          	return false;
   		}
  		public void swap(PairPoint pp) {
  			pp.p1.swap(this.p1);
  			pp.p2.swap(this.p2);
  		}
  		
  		public String toString () {
  			return p1.toString()+p2.toString();
  		}
  		public boolean equals (PairPoint pp) {
  			if(p1.equals(pp.p1) && p2.equals(pp.p2))
  				return true;
  			return false;
  		}
  	}
  	static class Scanner {
  		StringTokenizer st;
  		BufferedReader br;
   
  		public Scanner(InputStream s) {
  			br = new BufferedReader(new InputStreamReader(s));
  		}
   
  		public Scanner(FileReader r) {
  			br = new BufferedReader(r);
  		}
   
  		public String next() throws IOException {
  			while (st == null || !st.hasMoreTokens())
  				st = new StringTokenizer(br.readLine());
  			return st.nextToken();
  		}
   
  		public int nextInt() throws IOException {
  			return Integer.parseInt(next());
  		}
   
  		public long nextLong() throws IOException {
  			return Long.parseLong(next());
  		}
   
  		public String nextLine() throws IOException {
  			return br.readLine();
  		}
   
  		public double nextDouble() throws IOException {
  			String x = next();
  			StringBuilder sb = new StringBuilder("0");
  			double res = 0, f = 1;
  			boolean dec = false, neg = false;
  			int start = 0;
  			if (x.charAt(0) == '-') {
  				neg = true;
  				start++;
  			}
  			for (int i = start; i < x.length(); i++)
  				if (x.charAt(i) == '.') {
  					res = Long.parseLong(sb.toString());
  					sb = new StringBuilder("0");
  					dec = true;
  				} else {
  					sb.append(x.charAt(i));
  					if (dec)
  						f *= 10;
  				}
  			res += Long.parseLong(sb.toString()) / f;
  			return res * (neg ? -1 : 1);
  		}
   
  		public long[] nextlongArray(int n) throws IOException {
  			long[] a = new long[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextLong();
  			return a;
  		}
   
  		public Long[] nextLongArray(int n) throws IOException {
  			Long[] a = new Long[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextLong();
  			return a;
  		}
   
  		public int[] nextIntArray(int n) throws IOException {
  			int[] a = new int[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextInt();
  			return a;
  		}
   
  		public Integer[] nextIntegerArray(int n) throws IOException {
  			Integer[] a = new Integer[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextInt();
  			return a;
  		}
   
  		public boolean ready() throws IOException {
  			return br.ready();
  		}
   
  	}
   
  }