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.*;
  import java.util.*;
  import java.util.stream.Collectors;
  
  public class CodeForces {
  
      /**
       * У Василия есть два числа a и b, изначально равные нулю. Василий очень быстро научился делать с ними три
       * различные операции. Перед выполнением каждой операции выбирается некоторое целое положительное число k, с
       * помощью которого производится одна из операций: (обратите внимание, что для каждой операции вы можете выбрать
       * новое число k)
       * <p>
       * прибавить к a и b число k, или
       * прибавить к a число k и отнять от b число k, или
       * прибавить к b число k и отнять от a число k.
       * Обратите внимание, что в результате выполнения операций, числа a и b могут становиться в том числе
       * отрицательными.
       * <p>
       * Василий хочет узнать, какое минимальное количество операций ему потребуется совершить, чтобы число a стало
       * равно числу c, а число b стало равно d.
       * <p>
       * Входные данные
       * Во входных данных находятся несколько наборов входных данных. В первой строке находится одно целое число t
       * (1≤t≤104) — количество наборов входных данных. Далее следуют наборы входных данных.
       * <p>
       * Единственная строка каждого набора входных данных содержит два целых числа c и d (0≤c,d≤109) — числа, в
       * которые Василий хочет преобразовать a и b.
       * <p>
       * Выходные данные
       * Для каждого набора входных данных выведите одно целое число — минимальное количество операций, которое
       * потребуется Василию, чтобы число a стало равно c, а b равно d, или −1, если невозможно добиться равенств,
       * используя описанные операции.
       */
  
      public static class ContestSolution extends Solution {
  
          void solve() {
              int c = in.nextInt();
              int d = in.nextInt();
              if (c == 0 && d == 0) {
                  out.println(0);
              } else if (Math.abs(c) == Math.abs(d)) {
                  out.println(1);
              } else if ((c - d) % 2 == 0) {
                  out.println(2);
              } else {
                  out.println(-1);
              }
          }
      }
  
      /**
       * add `-Xss256m` to increase stack size
       */
      public static void main(String[] args) {
          boolean local = args.length > 0;
  //        boolean local = false;
          String input = local ? "codeforces/input.txt" : null;
  
          Solution solution = new ContestSolution();
          solution.in = new MyScanner(input);
          solution.out = MyWriter.of(null);
          solution.bm = new Benchmark();
          solution.al = new Algorithm();
          solution.run();
          solution.out.close();
      }
  
      public static class Solution {
          public MyScanner in;
          public MyWriter out;
          public Benchmark bm;
          public Algorithm al;
  
          void init() {
          }
  
          void solve() {
          }
  
          boolean isMultiTest() {
              return true;
          }
  
          void run() {
              init();
              if (isMultiTest()) {
                  int t = in.nextInt();
                  for (int i = 0; i < t; i++) {
                      solve();
                  }
              } else {
                  solve();
              }
          }
  
      }
  
      public static class Algorithm {
          public void sort(int[] arr) {
              List<Integer> tmp = Arrays.stream(arr).boxed().sorted().collect(Collectors.toList());
              for (int i = 0; i < arr.length; i++) {
                  arr[i] = tmp.get(i);
              }
          }
  
          public void sortRev(int[] arr) {
              List<Integer> tmp = Arrays.stream(arr).boxed().sorted(Comparator.comparing((Integer x) -> x).reversed())
                      .collect(Collectors.toList());
              for (int i = 0; i < arr.length; i++) {
                  arr[i] = tmp.get(i);
              }
          }
      }
  
      public static class ModInt {
          static int MOD = 1000000007;
  
          public static final ModInt ZERO = new ModInt(0);
          public static final ModInt ONE = new ModInt(1);
  
          private static final Map<ModInt, ModInt> inverseCache = new HashMap<>();
  
          private final int value;
  
          public ModInt(int value) {
              if (value < 0) {
                  throw new IllegalArgumentException();
              }
              this.value = value;
          }
  
          public ModInt add(ModInt other) {
              return new ModInt((int) (((long) this.value + other.value) % MOD));
          }
  
          public ModInt subtract(ModInt other) {
              return new ModInt((int) (((long) this.value - other.value + MOD) % MOD));
          }
  
          public ModInt multiply(ModInt other) {
              return new ModInt((int) (((long) this.value * other.value) % MOD));
          }
  
          public ModInt pow(int degree) {
              if (degree == 0) {
                  return ModInt.ONE;
              }
              if (degree % 2 == 1) {
                  return this.multiply(pow(degree - 1));
              }
              ModInt tmp = this.pow(degree / 2);
              return tmp.multiply(tmp);
          }
  
          public ModInt inverse() {
              ModInt tmp = inverseCache.get(this);
              if (tmp == null) {
                  tmp = this.pow(MOD - 2);
                  inverseCache.put(this, tmp);
              }
              return tmp;
          }
  
          public ModInt divide(ModInt other) {
              return this.multiply(other.inverse());
          }
      }
  
      public static class MyScanner {
          BufferedReader br;
          StringTokenizer st;
  
          public MyScanner(String fileName) {
              if (fileName != null) {
                  try {
                      br = new BufferedReader(new FileReader(fileName));
                  } catch (FileNotFoundException e) {
                      throw new RuntimeException(e);
                  }
              } else {
                  br = new BufferedReader(new InputStreamReader(System.in));
              }
          }
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  st = new StringTokenizer(nextLine());
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          int[] nextInts(int n) {
              int[] arr = new int[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextInt();
              }
              return arr;
          }
  
          boolean[] nextLineBools() {
              String line = nextLine();
              int n = line.length();
              boolean[] booleans = new boolean[n];
              for (int i = 0; i < n; i++) {
                  booleans[i] = line.charAt(i) == '1';
              }
              return booleans;
          }
  
          char[] nextLineChars() {
              String line = nextLine();
              int n = line.length();
              char[] chars = new char[n];
              for (int i = 0; i < n; i++) {
                  chars[i] = line.charAt(i);
              }
              return chars;
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          public long[] nextLongs(int n) {
              long[] arr = new long[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextLong();
              }
              return arr;
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              try {
                  String line = br.readLine();
                  if (line == null) {
                      throw new RuntimeException("empty line");
                  }
                  st = null;
                  return line;
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
          }
      }
  
      public static class MyWriter extends PrintWriter {
  
          public static MyWriter of(String fileName) {
              if (fileName != null) {
                  try {
                      return new MyWriter(new FileWriter(fileName));
                  } catch (IOException e) {
                      throw new RuntimeException(e);
                  }
              } else {
                  return new MyWriter(new BufferedOutputStream(System.out));
              }
          }
  
          public MyWriter(FileWriter fileWriter) {
              super(fileWriter);
          }
  
          public MyWriter(OutputStream out) {
              super(out);
          }
  
          void println(int[] arr) {
              String line = Arrays.stream(arr).mapToObj(String::valueOf).collect(Collectors.joining(" "));
              println(line);
          }
  
      }
  
      public static class Benchmark {
          long time;
  
          public void start() {
              time = System.currentTimeMillis();
          }
  
          public long calc() {
              long curTime = System.currentTimeMillis();
              long tmp = curTime - time;
              time = curTime;
              return tmp;
          }
  
      }
  }
  