description: Tanya is learning how to add numbers, but so far she is not doing it correctly. She is adding two numbers a and b using the following algorithm:
  
    1. If one of the numbers is shorter than the other, Tanya adds leading zeros so that the numbers are the same length. 
    2. The numbers are processed from right to left (that is, from the least significant digits to the most significant). 
    3. In the first step, she adds the last digit of a to the last digit of b and writes their sum in the answer. 
    4. At each next step, she performs the same operation on each pair of digits in the same place and writes the result to the left side of the answer. 
  
  
  
  For example, the numbers a = 17236 and b = 3465 Tanya adds up as follows:
  
  $$$ \large{ \begin{array}{r} + \begin{array}{r} 17236\\\ 03465\\\ \end{array} \\\ \hline \begin{array}{r} 1106911 \end{array} \end{array}} $$$
  
    * calculates the sum of 6 + 5 = 11 and writes 11 in the answer. 
    * calculates the sum of 3 + 6 = 9 and writes the result to the left side of the answer to get 911. 
    * calculates the sum of 2 + 4 = 6 and writes the result to the left side of the answer to get 6911. 
    * calculates the sum of 7 + 3 = 10, and writes the result to the left side of the answer to get 106911. 
    * calculates the sum of 1 + 0 = 1 and writes the result to the left side of the answer and get 1106911. 
  
  
  
  As a result, she gets 1106911.
  
  You are given two positive integers a and s. Find the number b such that by adding a and b as described above, Tanya will get s. Or determine that no suitable b exists.
  
  Input
  
  The first line of input data contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
  
  Each test case consists of a single line containing two positive integers a and s (1 ≤ a < s ≤ 10^{18}) separated by a space.
  
  Output
  
  For each test case print the answer on a separate line.
  
  If the solution exists, print a single positive integer b. The answer must be written without leading zeros. If multiple answers exist, print any of them.
  
  If no suitable number b exists, output -1.
  
  Example
  
  Input
  
  
  6
  17236 1106911
  1 5
  108 112
  12345 1023412
  1 11
  1 20
  
  
  Output
  
  
  3465
  4
  -1
  90007
  10
  -1
  
  Note
  
  The first test case is explained in the main part of the statement.
  
  In the third test case, we cannot choose b that satisfies the problem statement.
solution: import java.io.IOException;
  import java.io.InputStream;
  import java.io.PrintWriter; // System.out is a PrintStream
  import java.util.InputMismatchException;
  
  
  public class C {
      private static int MOD = (int)1e9 + 7, mod = 99_82_44_353;
      private static double PI = 3.14159265358979323846;
      private static StringBuilder ans;
  
      public static void main(String[] args) throws IOException {
          FasterScanner scn = new FasterScanner();
          PrintWriter out = new PrintWriter(System.out);
          for (int tc = scn.nextInt(); tc > 0; tc--) {
              ans = new StringBuilder();
              char[] arr = scn.next().toCharArray(), srr = scn.next().toCharArray();
              boolean flag = true;
              int idx1, idx2;
              for (idx1 = arr.length - 1, idx2 = srr.length - 1; idx1 >= 0; idx1--, idx2--) {
                  if (idx2 < 0) {
                      flag = false;
                      break;
                  }
                  int val1 = arr[idx1] - '0', val2 = srr[idx2] - '0';
                  if (val1 <= val2) {
                      int diff = val2 - val1;
                      ans.append(diff);
                  } else {
                      if (idx2 == 0 || srr[idx2 - 1] != '1') {
                          flag = false;
                          break;
                      } else {
                          val2 += 10;
                          ans.append(val2 - val1);
                          idx2--;
                      }
                  }
              }
              flag = flag && idx1 < 0;
              if (!flag) {
                  out.println("-1");
                  continue;
              }
              while (idx2 >= 0) {
                  int val2 = srr[idx2] - '0';
                  ans.append(val2);
                  idx2--;
              }
              flag = false;
              for (int i = ans.length() - 1; i >= 0; i--) {
                  if (ans.charAt(i) == '0' && !flag) continue;
                  flag = true;
                  out.print(ans.charAt(i));
              }
              out.println();
          }
          out.close();
      }
  
  
      /* ------------------- Sorting ------------------- */
      private static void ruffleSort(int[] arr) {
          // int N = arr.length;
          // Random rand = new Random();
          // for (int i = 0; i < N; i++) {
          //     int oi = rand.nextInt(N), temp = arr[i];
          //     arr[i] = arr[oi];
          //     arr[oi] = temp;
          // }
          // Arrays.sort(arr);
      }
          
      /* ------------------- Sorting ------------------- */
      
      private static boolean isPalindrome(String str) {
          for (int i = 0, j = str.length() - 1; i < j; i++, j--) {
              if (str.charAt(i) != str.charAt(j)) {
                  return false;
              }
          }
          return true;
      }
      
      private static boolean isPalindrome(char[] str) {
          for (int i = 0, j = str.length - 1; i < j; i++, j--) {
              if (str[i] != str[j]) {
                  return false;
              }
          }
          return true;
      }
      
      /* ------------------- Pair class ------------------- */
      private static class Pair implements Comparable<Pair> {
  		int x, y;
  		Pair(int x, int y) {
  			this.x = x;
  			this.y = y;
  		}
  		public int compareTo(Pair o) {
  			return this.x == o.x ? this.y - o.y : this.x - o.x;
  		}
  	}
  
      /* ------------------- HCF and LCM ------------------- */
      private static int gcd(int num1, int num2) {
          int temp = 0;
          while (num2 != 0) {
              temp = num1;
              num1 = num2;
              num2 = temp % num2;
          }
          return num1;
      }
      
      private static int lcm(int num1, int num2) {
          return (int)((1L * num1 * num2) / gcd(num1, num2));
      }
      
      /* ------------------- primes and prime factorization ------------------- */
      private static boolean[] seive(int N) {
          // true means not prime, false means is a prime number :)
          boolean[] notPrimes = new boolean[N + 1];
          notPrimes[0] = notPrimes[1] = true;
          for (int i = 2; i * i <= N; i++) {
              if (notPrimes[i]) continue;
              for (int j = i * i; j <= N; j += i) {
                  notPrimes[j] = true;
              }
          }
          return notPrimes;
      }
  
  	/*
      private static TreeMap<Integer, Integer> primeFactors(long N) {
  		TreeMap<Integer, Integer> primeFact = new TreeMap<>();
  		for (int i = 2; i <= Math.sqrt(N); i++) {
              int count = 0;
              while (N % i == 0) {
                  N /= i;
                  count++;
              }
              if (count != 0) {
                  primeFact.put(i, count);
              }
  		}
  		if (N != 1) {
              primeFact.put((int)N, 1);
          }
  		return primeFact;
  	}
      */
  
      /* ------------------- Binary Search ------------------- */
      private static long factorial(int N) {
          long ans = 1L;
          for (int i = 2; i <= N; i++) {
              ans *= i;
          }
          return ans;
      }
  
      private static long[] factorialDP(int N) {
          long[] factDP = new long[N + 1];
          factDP[0] = factDP[1] = 1;
          for (int i = 2; i <= N; i++) {
              factDP[i] = factDP[i - 1] * i;
          }
          return factDP;
      }
  
      private static long factorialMod(int N, int mod) {
          long ans = 1L;
          for (int i = 2; i <= N; i++) {
              ans = ((ans % mod) * (i % mod)) % mod;
          }
          return ans;
      }
  
      /* ------------------- Binary Search ------------------- */
      private static int floorSearch(int[] arr, int st, int ed, int tar) {
          int ans = -1;
          while (st <= ed) {
              int mid = ((ed - st) >> 1) + st;
              if (arr[mid] <= tar) {
                  ans = mid;
                  st = mid + 1;
              } else {
                  ed = mid - 1;
              }
          }
          return ans;
      }
      
      private static int ceilingSearch(int[] arr, int st, int ed, int tar) {
          int ans = -1;
          while (st <= ed) {
              int mid = ((ed - st) >> 1) + st;
              if (arr[mid] < tar) {
                  st = mid + 1;
              } else {
                  ans = mid;
                  ed = mid - 1;
              }
          }
          return ans;
      }
      
      /* ------------------- Power Function ------------------- */
      public static long pow(long x, long y) {
          long res = 1;
  		while (y > 0) {
              if ((y & 1) != 0) {
                  res = (res * x);
  				y--;
  			}
  			x = (x * x);
  			y >>= 1;
  		}
  		return res;
  	}
      
  	public static long powMod(long x, long y, int mod) {
          long res = 1;
  		while (y > 0) {
              if ((y & 1) != 0) {
                  res = (res * x) % mod;
  				y--;
  			}
  			x = (x * x) % mod;
  			y >>= 1;
  		}
  		return res % mod;
  	}
  
      /* ------------------- Disjoint Set(Union and Find) ------------------- */
      private static class DSU {
  		public int[] parent, rank;
  		DSU(int N) {
  			parent = new int[N];
  			rank = new int[N];
  			for (int i = 0; i < N; i++) {
  				parent[i] = i;
                  rank[i] = 1;
              }
  		}
  		public int find(int a) {
  			if (parent[a] == a) {
  				return a;
              }
              return parent[a] = find(parent[a]);
  		}
  		public boolean union(int a, int b) {
  			int parA = find(a), parB = find(b);
  			if (parA == parB) return false;
  			if (rank[parA] > rank[parB]) {
                  parent[parB] = parA;
              } else if (rank[parA] < rank[parB]) {
                  parent[parA] = parB;
              } else {
                  parent[parA] = parB;
                  rank[parB]++;
              }
              return true;
  		}
  	}
      
      /* ------------------- Scanner class for input ------------------- */
      
      private static class FasterScanner {
  		private InputStream stream;
  		private byte[] buffer = new byte[1024];
  		private int curChar, numChars;
  		private SpaceCharFilter filter;
  
  		public FasterScanner() {
              // default
  			this.stream = System.in;
  		}
  
  		public FasterScanner(InputStream stream) {
  			this.stream = stream;
  		}
  
  		private int readChar() {
  			if (numChars == -1) {
  				throw new InputMismatchException();
              }
  			if (curChar >= numChars) {
  				curChar = 0;
  				try {
  					numChars = stream.read(buffer);
  				} catch (IOException e) {
  					throw new InputMismatchException(e.getMessage());
  				}
  				if (numChars <= 0) {
  					return -1;
                  }
  			}
  			return buffer[curChar++];
  		}
  
  		private boolean isWhiteSpace(int c) {
  			if (filter != null) {
  				return filter.isWhiteSpace(c);
              }
  			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  		}
  
  		private boolean isNewLine(int ch) {
  			if (filter != null) {
  				return filter.isNewLine(ch);
              }
  			return ch == '\r' || ch == '\n' || ch == -1;
  		}
  
          public char nextChar() {
              int ch = readChar();
              char res = '\0';
              while (isWhiteSpace(ch)) {
                  ch = readChar();
              }
              do {
                  res = (char)ch;
                  ch = readChar();
              } while (!isWhiteSpace(ch));
              return res;
          }
  
  		public String next() {
  			int ch = readChar();
              StringBuilder res = new StringBuilder();
  			while (isWhiteSpace(ch)) {
  				ch = readChar();
              }
  			do {
  				res.appendCodePoint(ch);
  				ch = readChar();
  			} while (!isWhiteSpace(ch));
  			return res.toString();
  		}
  
  		public String nextLine() {
  			int ch = readChar();
              StringBuilder res = new StringBuilder();
  			do {
  				res.appendCodePoint(ch);
  				ch = readChar();
  			} while (!isNewLine(ch));
  			return res.toString();
  		}
  
  		public int nextInt() {
  			int ch = -1, sgn = 1, res = 0;
              do {
                  ch = readChar();
              } while (isWhiteSpace(ch));
  			if (ch == '-') {
  				sgn = -1;
  				ch = readChar();
  			}
  			do {
  				if (ch < '0' || ch > '9') {
  					throw new InputMismatchException("not a number");
                  }
  				res = (res * 10) + (ch - '0');
  				ch = readChar();
  			} while (!isWhiteSpace(ch));
              
  			return res * sgn;
  		}
  
  		public long nextLong() {
  			int ch = -1, sgn = 1;
              long res = 0L;
              do {
                  ch = readChar();
              } while (isWhiteSpace(ch));
  			if (ch == '-') {
  				sgn = -1;
  				ch = readChar();
  			}
  			do {
  				if (ch < '0' || ch > '9') {
  					throw new InputMismatchException("not a number");
                  }
  				res = (10L * res) + (ch - '0');
  				ch = readChar();
  			} while (!isWhiteSpace(ch));
  
  			return 1L * res * sgn;
  		}
  
          public double nextDouble() {
              return Double.parseDouble(next());
          }
  
          /* for custom delimiters */
  		public interface SpaceCharFilter {
  			public boolean isWhiteSpace(int ch);
  			public boolean isNewLine(int ch);
  		}
  	}
  }
  