description: Monocarp wrote down two numbers on a whiteboard. Both numbers follow a specific format: a positive integer x with p zeros appended to its end.
  
  Now Monocarp asks you to compare these two numbers. Can you help him?
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of testcases.
  
  The first line of each testcase contains two integers x_1 and p_1 (1 ≤ x_1 ≤ 10^6; 0 ≤ p_1 ≤ 10^6) — the description of the first number.
  
  The second line of each testcase contains two integers x_2 and p_2 (1 ≤ x_2 ≤ 10^6; 0 ≤ p_2 ≤ 10^6) — the description of the second number.
  
  Output
  
  For each testcase print the result of the comparison of the given two numbers. If the first number is smaller than the second one, print '<'. If the first number is greater than the second one, print '>'. If they are equal, print '='.
  
  Example
  
  Input
  
  
  5
  2 1
  19 0
  10 2
  100 1
  1999 0
  2 3
  1 0
  1 0
  99 0
  1 2
  
  
  Output
  
  
  &gt;
  =
  &lt;
  =
  &lt;
  
  Note
  
  The comparisons in the example are: 20 > 19, 1000 = 1000, 1999 < 2000, 1 = 1, 99 < 100.
solution: import java.io.*;
  import java.util.*;
  public class Main {
      private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
      private FastWriter wr;
      private Reader rd;
      public final int MOD = 1000000007;
  
      /************************************************** FAST INPUT IMPLEMENTATION *********************************************/
      class Reader {
          BufferedReader br;
          StringTokenizer st;
  
          public Reader() {
              br = new BufferedReader(
                      new InputStreamReader(System.in));
          }
  
          public Reader(String path) throws FileNotFoundException {
              br = new BufferedReader(
                      new InputStreamReader(new FileInputStream(path)));
          }
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  
      public int ni() throws IOException {
          return rd.nextInt();
      }
  
      public long nl() throws IOException {
          return rd.nextLong();
      }
  
      char nc() throws IOException {
          return rd.next().charAt(0);
      }
  
      public String ns() throws IOException {
          return rd.nextLine();
      }
  
      public Double nd() throws IOException {
          return rd.nextDouble();
      }
  
      public int[] nai(int n) throws IOException {
          int[] arr = new int[n];
          for (int i = 0; i < n; i++) {
              arr[i] = ni();
          }
          return arr;
      }
  
      public long[] nal(int n) throws IOException {
          long[] arr = new long[n];
          for (int i = 0; i < n; i++) {
              arr[i] = nl();
          }
          return arr;
      }
  
      /************************************************** FAST OUTPUT IMPLEMENTATION *********************************************/
      public static class FastWriter {
          private static final int BUF_SIZE = 1 << 13;
          private final byte[] buf = new byte[BUF_SIZE];
          private final OutputStream out;
          private int ptr = 0;
  
          private FastWriter() {
              out = null;
          }
  
          public FastWriter(OutputStream os) {
              this.out = os;
          }
  
          public FastWriter(String path) {
              try {
                  this.out = new FileOutputStream(path);
              } catch (FileNotFoundException e) {
                  throw new RuntimeException("FastWriter");
              }
          }
  
          public FastWriter write(byte b) {
              buf[ptr++] = b;
              if (ptr == BUF_SIZE) innerflush();
              return this;
          }
  
          public FastWriter write(char c) {
              return write((byte) c);
          }
  
          public FastWriter write(char[] s) {
              for (char c : s) {
                  buf[ptr++] = (byte) c;
                  if (ptr == BUF_SIZE) innerflush();
              }
              return this;
          }
  
          public FastWriter write(String s) {
              s.chars().forEach(c -> {
                  buf[ptr++] = (byte) c;
                  if (ptr == BUF_SIZE) innerflush();
              });
              return this;
          }
  
          private static int countDigits(int l) {
              if (l >= 1000000000) return 10;
              if (l >= 100000000) return 9;
              if (l >= 10000000) return 8;
              if (l >= 1000000) return 7;
              if (l >= 100000) return 6;
              if (l >= 10000) return 5;
              if (l >= 1000) return 4;
              if (l >= 100) return 3;
              if (l >= 10) return 2;
              return 1;
          }
  
          public FastWriter write(int x) {
              if (x == Integer.MIN_VALUE) {
                  return write((long) x);
              }
              if (ptr + 12 >= BUF_SIZE) innerflush();
              if (x < 0) {
                  write((byte) '-');
                  x = -x;
              }
              int d = countDigits(x);
              for (int i = ptr + d - 1; i >= ptr; i--) {
                  buf[i] = (byte) ('0' + x % 10);
                  x /= 10;
              }
              ptr += d;
              return this;
          }
  
          private static int countDigits(long l) {
              if (l >= 1000000000000000000L) return 19;
              if (l >= 100000000000000000L) return 18;
              if (l >= 10000000000000000L) return 17;
              if (l >= 1000000000000000L) return 16;
              if (l >= 100000000000000L) return 15;
              if (l >= 10000000000000L) return 14;
              if (l >= 1000000000000L) return 13;
              if (l >= 100000000000L) return 12;
              if (l >= 10000000000L) return 11;
              if (l >= 1000000000L) return 10;
              if (l >= 100000000L) return 9;
              if (l >= 10000000L) return 8;
              if (l >= 1000000L) return 7;
              if (l >= 100000L) return 6;
              if (l >= 10000L) return 5;
              if (l >= 1000L) return 4;
              if (l >= 100L) return 3;
              if (l >= 10L) return 2;
              return 1;
          }
  
          public FastWriter write(long x) {
              if (x == Long.MIN_VALUE) {
                  return write("" + x);
              }
              if (ptr + 21 >= BUF_SIZE) innerflush();
              if (x < 0) {
                  write((byte) '-');
                  x = -x;
              }
              int d = countDigits(x);
              for (int i = ptr + d - 1; i >= ptr; i--) {
                  buf[i] = (byte) ('0' + x % 10);
                  x /= 10;
              }
              ptr += d;
              return this;
          }
  
          public FastWriter write(double x, int precision) {
              if (x < 0) {
                  write('-');
                  x = -x;
              }
              x += Math.pow(10, -precision) / 2;
              //		if(x < 0){ x = 0; }
              write((long) x).write(".");
              x -= (long) x;
              for (int i = 0; i < precision; i++) {
                  x *= 10;
                  write((char) ('0' + (int) x));
                  x -= (int) x;
              }
              return this;
          }
  
          public FastWriter writeln(char c) {
              return write(c).writeln();
          }
  
          public FastWriter writeln(int x) {
              return write(x).writeln();
          }
  
          public FastWriter writeln(long x) {
              return write(x).writeln();
          }
  
          public FastWriter writeln(double x, int precision) {
              return write(x, precision).writeln();
          }
  
          public FastWriter write(int... xs) {
              boolean first = true;
              for (int x : xs) {
                  if (!first) write(' ');
                  first = false;
                  write(x);
              }
              return this;
          }
  
          public FastWriter write(long... xs) {
              boolean first = true;
              for (long x : xs) {
                  if (!first) write(' ');
                  first = false;
                  write(x);
              }
              return this;
          }
  
          public FastWriter writeln() {
              return write((byte) '\n');
          }
  
          public FastWriter writeln(int... xs) {
              return write(xs).writeln();
          }
  
          public FastWriter writeln(long... xs) {
              return write(xs).writeln();
          }
  
          public FastWriter writeln(char[] line) {
              return write(line).writeln();
          }
  
          public FastWriter writeln(char[]... map) {
              for (char[] line : map) write(line).writeln();
              return this;
          }
  
          public FastWriter writeln(String s) {
              return write(s).writeln();
          }
  
          private void innerflush() {
              try {
                  out.write(buf, 0, ptr);
                  ptr = 0;
              } catch (IOException e) {
                  throw new RuntimeException("innerflush");
              }
          }
  
          public void flush() {
              innerflush();
              try {
                  out.flush();
              } catch (IOException e) {
                  throw new RuntimeException("flush");
              }
          }
  
          public FastWriter print(byte b) {
              return write(b);
          }
  
          public FastWriter print(char c) {
              return write(c);
          }
  
          public FastWriter print(char[] s) {
              return write(s);
          }
  
          public FastWriter print(String s) {
              return write(s);
          }
  
          public FastWriter print(int x) {
              return write(x);
          }
  
          public FastWriter print(long x) {
              return write(x);
          }
  
          public FastWriter print(double x, int precision) {
              return write(x, precision);
          }
  
          public FastWriter println(char c) {
              return writeln(c);
          }
  
          public FastWriter println(int x) {
              return writeln(x);
          }
  
          public FastWriter println(long x) {
              return writeln(x);
          }
  
          public FastWriter println(double x, int precision) {
              return writeln(x, precision);
          }
  
          public FastWriter print(int... xs) {
              return write(xs);
          }
  
          public FastWriter print(long... xs) {
              return write(xs);
          }
  
          public FastWriter println(int... xs) {
              return writeln(xs);
          }
  
          public FastWriter println(long... xs) {
              return writeln(xs);
          }
  
          public FastWriter println(char[] line) {
              return writeln(line);
          }
  
          public FastWriter println(char[]... map) {
              return writeln(map);
          }
  
          public FastWriter println(String s) {
              return writeln(s);
          }
  
          public FastWriter println() {
              return writeln();
          }
      }
  
  
      /********************************************************* USEFUL CODE **************************************************/
      boolean[] SAPrimeGenerator(int n) {
          // TC-N*LOG(LOG N)
          //Create Prime Marking Array and fill it with true value
          boolean[] primeMarker = new boolean[n + 1];
          Arrays.fill(primeMarker, true);
          primeMarker[0] = false;
          primeMarker[1] = false;
          for (int i = 2; i <= n; i++) {
              if (primeMarker[i]) {
                  // we start from 2*i because i*1 must be prime
                  for (int j = 2 * i; j <= n; j += i) {
                      primeMarker[j] = false;
                  }
              }
          }
          return primeMarker;
      }
  
      private void tr(Object... o) {
          if (!oj) System.out.println(Arrays.deepToString(o));
      }
  
      class Pair<F, S> {
          private F first;
          private S second;
  
          Pair(F first, S second) {
              this.first = first;
              this.second = second;
          }
  
          public F getFirst() {
              return first;
          }
  
          public S getSecond() {
              return second;
          }
  
          @Override
          public String toString() {
              return "Pair{" +
                      "first=" + first +
                      ", second=" + second +
                      '}';
          }
  
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
              Pair<?, ?> pair = (Pair<?, ?>) o;
              return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
          }
      }
  
      public static void main(String[] args) throws IOException {
          new Main().run();
      }
  
      public void run() throws IOException {
          if (oj) {
              rd = new Reader();
              wr = new FastWriter(System.out);
          } else {
              File input = new File("input.txt");
              File output = new File("output.txt");
              if (input.exists() && output.exists()) {
                  rd = new Reader(input.getPath());
                  wr = new FastWriter(output.getPath());
              } else {
                  rd = new Reader();
                  wr = new FastWriter(System.out);
                  oj = true;
              }
          }
          long s = System.currentTimeMillis();
          solve();
          wr.flush();
          tr(System.currentTimeMillis() - s + "ms");
      }
  
      /***************************************************************************************************************************
       *********************************************************** MAIN CODE ******************************************************
       ****************************************************************************************************************************/
  
      public void solve() throws IOException {
          int t = ni();
          while (t-- > 0) {
              go();
          }
      }
  
      /********************************************************* MAIN LOGIC HERE ****************************************************/
  
  
      public void go() throws IOException {
          long x1,x2,p1,p2;
          x1=nl();
          p1=nl();
          x2=nl();
          p2=nl();
  
          long cx1=FastWriter.countDigits(x1);
          long cx2=FastWriter.countDigits(x2);
  
          if(cx1+p1>cx2+p2){
              wr.println(">");
          }else if(cx1+p1<cx2+p2){
              wr.println("<");
          }else {
              long max=Math.max(cx1,cx2);
              x1*=Math.pow(10,Math.abs(cx1-max));
              x2*=Math.pow(10,Math.abs(cx2-max));
              if(x1>x2){
                  wr.println(">");
              }else if(x1<x2){
                  wr.println("<");
              }else {
                  wr.println("=");
              }
          }
      }
  }
  
  