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.io.BufferedReader;
      import java.io.FileInputStream;
      import java.io.FileNotFoundException;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.util.*;
      import java.io.PrintStream;
                  //import java.util.*;
  
              public class Solution {
  
                  public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
  
                  static class FastScanner {
  
                          BufferedReader br;
                          StringTokenizer st ;
  
                          FastScanner(){
                              br =  new BufferedReader(new InputStreamReader(System.in));
                              st = new StringTokenizer("");
                          }
  
                          FastScanner(String file) {
  
                              try {
                                  br =  new BufferedReader(new InputStreamReader(new FileInputStream(file)));
                                  st = new StringTokenizer("");
                              } catch (FileNotFoundException e) {
                                  // TODO Auto-generated catch block
                                  System.out.println("file not found");
                                  e.printStackTrace();
                              }
                              
                          }
                          
  
                          String next() {
                              while (!st.hasMoreTokens())
                                  try {
                                      st = new StringTokenizer(br.readLine());
                                  } catch (IOException e) {
                                  }
                              return st.nextToken();
                          }
  
                          int nextInt() {
                              return Integer.parseInt(next());
                          }
  
                          long nextLong() {
                              return Long.parseLong(next());
                          }
                          String readLine() throws IOException{
                              return br.readLine();
                          }
                      }
                                          
                  static class Pair<T,X>{
                      T first;
                      X second;
                      Pair(T first,X second){
                          this.first = first;
                          this.second = second;
                      }
  
                      @Override
                      public int hashCode(){
                          return Objects.hash(first,second);
                      }
  
                      @Override
                      public boolean equals(Object obj){
                          return obj.hashCode() == this.hashCode();
                      }
  
                  }
  
              
              public static void main(String[] args) throws Exception {
                  
                  FastScanner s = new FastScanner();
  
                  
                  if(LOCAL){
                      s = new FastScanner("src/input.txt");
                      PrintStream o = new PrintStream("src/sampleout.txt");
                      System.setOut(o);
                  }
  
                  int tcr = s.nextInt();
  
                  
                  for(int tc=0;tc<tcr;tc++){
  
                      int num1 = s.nextInt();
                      int num2 = s.nextInt();
  
                      if(num1 == 0  && num2 == 0){
                          println("0");
                          continue;
                      }
  
                      if(num1 == num2){
                          println("1");
                          continue;
                      }
  
                      if(Math.abs(num1 - num2) % 2 == 0){
                          println("2");
                      }else{
                          println("-1");
                      }
                      
                  }                
              }
  
              public static TreeSet<Integer> solve(int ta,int tb,int wa,int wb){
  
                  TreeSet<Integer> set = new TreeSet<>();
                  
                  for(int i=0;i<=wa;i++){
                      
                      int a_1 = i;
                      int a_0 = wa - a_1;
                      int b_1 = (ta - a_1);
                      int b_0 = wb - b_1;
  
                      if(a_1 >= 0 && a_0 >= 0 && b_1 >= 0 && b_0 >= 0){
                          set.add(a_1 + b_0);
                      }
                  }
  
                  return set;
              }
  
              public static long modpow(long num,long pow,long mod){
  
                  long val = num;
                  long ans = 1l;
  
                  while(pow > 0l){
                      
                      long bit = pow & 1l;
  
                      if(bit == 1){
                          ans = (ans * (val%mod))%mod;
                      }
                      val = (val * val) % mod;
                      pow = pow >> 1;
                  }
  
                  return ans;
  
              }
  
              public static char get(int n){
                  return (char)('a' + n);
              }
  
              public static long[] sort(long arr[]){
                  List<Long> list = new ArrayList<>();
                  for(long n : arr){list.add(n);}
                  Collections.sort(list);
                  for(int i=0;i<arr.length;i++){
                      arr[i] = list.get(i);
                  }
                  return arr;
              }
  
              public static int[] sort(int arr[]){
                  List<Integer> list = new ArrayList<>();
                  for(int n : arr){list.add(n);}
                  Collections.sort(list);
                  for(int i=0;i<arr.length;i++){
                      arr[i] = list.get(i);
                  }
                  return arr;
              }
  
              // return the (index + 1)
              // where index is the pos of just smaller element
              // i.e count of elemets strictly less than num
              public static int justSmaller(long arr[],long num){
                  //  System.out.println(num+"@");
                  int st = 0;
                  int e = arr.length - 1;
          
                  int ans = -1;
          
                  while(st <= e){
          
                      int mid = (st + e)/2;
          
                      if(arr[mid] >= num){
                          e = mid - 1;
                      }else{
                          ans = mid;
                          st = mid + 1;
                      }
          
                  }
          
          
                  return ans + 1;
          
              }
              
              //return (index of just greater element)
              //count of elements smaller than or equal to num
  
              public static int justGreater(long arr[],long num){
                  int st = 0;
                  int e = arr.length - 1;
          
                  int ans = arr.length;
          
                  while(st <= e){
                      
                      int mid = (st + e)/2;
          
                      if(arr[mid] <= num){
                          st = mid + 1;
                      }else{
                          ans = mid;
                          e = mid - 1;
                      }
                  }
          
                  return ans;
          
              }
          
              
  
              public static void println(Object obj){
                  System.out.println(obj.toString());
              }
  
              public static void print(Object obj){
                  System.out.print(obj.toString());
              }
  
              public static int gcd(int a,int b){
                  if(b == 0){return a;}
                  return gcd(b,a%b);
              }
  
              public static long gcd(long a,long b){
                  if(b == 0l){
                      return a;
                  }
  
                  return gcd(b,a%b);
              }
  
              public static int find(int parent[],int v){
                  if(parent[v] == v){
                      return v;
                  }
                  
                  return parent[v] = find(parent, parent[v]);
              }
  
          
  
              public static List<Integer> sieve(){
              
                  List<Integer> prime = new ArrayList<>();
  
                  int arr[] = new int[100001];
  
                  Arrays.fill(arr,1);
  
                  arr[1] = 0;
                  arr[2] = 1;
  
                  for(int i=2;i<=100000;i++){
                      
                      if(arr[i] == 1){
                          
                          prime.add(i);
  
                          for(long j = (i*1l*i);j<100001;j+=i){
                              arr[(int)j] = 0;
                          }
                      }
                  }
  
                  return prime;
              }
  
              static boolean isPower(long n,long a){
                  
                  long log = (long)(Math.log(n)/Math.log(a));
  
                  long power = (long)Math.pow(a,log);
  
                  if(power == n){return true;}
  
                  return false;
              }
  
  
              private static int mergeAndCount(int[] arr, int l,int m, int r)
              {
  
                  // Left subarray
                  int[] left =  Arrays.copyOfRange(arr, l, m + 1);
  
                  // Right subarray
                  int[] right = Arrays.copyOfRange(arr, m + 1, r + 1);
  
                  int i = 0, j = 0, k = l, swaps = 0;
  
                  while (i < left.length && j < right.length) {
                      if (left[i] <= right[j])
                          arr[k++] = left[i++];
                      else {
                          arr[k++] = right[j++];
                          swaps += (m + 1) - (l + i);
                      }
                  }
                  while (i < left.length)
                      arr[k++] = left[i++];
                  while (j < right.length)
                      arr[k++] = right[j++];
                  return swaps;
              }
  
              // Merge sort function
              private static int mergeSortAndCount(int[] arr, int l,int r)
              {
  
                  // Keeps track of the inversion count at a
                  // particular node of the recursion tree
                  int count = 0;
  
                  if (l < r) {
                      int m = (l + r) / 2;
  
                      // Total inversion count = left subarray count
                      // + right subarray count + merge count
  
                      // Left subarray count
                      count += mergeSortAndCount(arr, l, m);
  
                      // Right subarray count
                      count += mergeSortAndCount(arr, m + 1, r);
  
                      // Merge count
                      count += mergeAndCount(arr, l, m, r);
                  }
  
                  return count;
              }
  
              static class Debug {
                  //change to System.getProperty("ONLINE_JUDGE")==null; for CodeForces
                  public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
                  private static <T> String ts(T t) {
                      if(t==null) {
                          return "null";
                      }
                      try {
                          return ts((Iterable) t);
                      }catch(ClassCastException e) {
                          if(t instanceof int[]) {
                              String s = Arrays.toString((int[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof long[]) {
                              String s = Arrays.toString((long[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof char[]) {
                              String s = Arrays.toString((char[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof double[]) {
                              String s = Arrays.toString((double[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof boolean[]) {
                              String s = Arrays.toString((boolean[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }
                          try {
                              return ts((Object[]) t);
                          }catch(ClassCastException e1) {
                              return t.toString();
                          }
                      }
                  }
                  private static <T> String ts(T[] arr) {
                      StringBuilder ret = new StringBuilder();
                      ret.append("{");
                      boolean first = true;
                      for(T t: arr) {
                          if(!first) {
                              ret.append(", ");
                          }
                          first = false;
                          ret.append(ts(t));
                      }
                      ret.append("}");
                      return ret.toString();
                  }
                  private static <T> String ts(Iterable<T> iter) {
                      StringBuilder ret = new StringBuilder();
                      ret.append("{");
                      boolean first = true;
                      for(T t: iter) {
                          if(!first) {
                              ret.append(", ");
                          }
                          first = false;
                          ret.append(ts(t));
                      }
                      ret.append("}");
                      return ret.toString();
                  }
                  public static void dbg(Object... o) throws Exception {
                      if(LOCAL) {
                          PrintStream ps = new PrintStream("src/Debug.txt");
                          System.setErr(ps);
                          System.err.print("Line #"+Thread.currentThread().getStackTrace()[2].getLineNumber()+": [");
                          for(int i = 0; i<o.length; i++) {
                              if(i!=0) {
                                  System.err.print(", ");
                              }
                              System.err.print(ts(o[i]));
                          }
                          System.err.println("]");
                      }
                  }
              }
  
      }