description: A rectangle with its opposite corners in (0, 0) and (w, h) and sides parallel to the axes is drawn on a plane.
  
  You are given a list of lattice points such that each point lies on a side of a rectangle but not in its corner. Also, there are at least two points on every side of a rectangle.
  
  Your task is to choose three points in such a way that: 
  
    * exactly two of them belong to the same side of a rectangle; 
    * the area of a triangle formed by them is maximum possible. 
  
  
  
  Print the doubled area of this triangle. It can be shown that the doubled area of any triangle formed by lattice points is always an integer.
  
  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 w and h (3 ≤ w, h ≤ 10^6) — the coordinates of the corner of a rectangle.
  
  The next two lines contain the description of the points on two horizontal sides. First, an integer k (2 ≤ k ≤ 2 ⋅ 10^5) — the number of points. Then, k integers x_1 < x_2 < ... < x_k (0 < x_i < w) — the x coordinates of the points in the ascending order. The y coordinate for the first line is 0 and for the second line is h.
  
  The next two lines contain the description of the points on two vertical sides. First, an integer k (2 ≤ k ≤ 2 ⋅ 10^5) — the number of points. Then, k integers y_1 < y_2 < ... < y_k (0 < y_i < h) — the y coordinates of the points in the ascending order. The x coordinate for the first line is 0 and for the second line is w.
  
  The total number of points on all sides in all testcases doesn't exceed 2 ⋅ 10^5.
  
  Output
  
  For each testcase print a single integer — the doubled maximum area of a triangle formed by such three points that exactly two of them belong to the same side.
  
  Example
  
  Input
  
  
  3
  5 8
  2 1 2
  3 2 3 4
  3 1 4 6
  2 4 5
  10 7
  2 3 9
  2 1 7
  3 1 3 4
  3 4 5 6
  11 5
  3 1 6 8
  3 3 6 8
  3 1 3 4
  2 2 4
  
  
  Output
  
  
  25
  42
  35
  
  Note
  
  The points in the first testcase of the example: 
  
    * (1, 0), (2, 0); 
    * (2, 8), (3, 8), (4, 8); 
    * (0, 1), (0, 4), (0, 6); 
    * (5, 4), (5, 5). 
  
  
  
  The largest triangle is formed by points (0, 1), (0, 6) and (5, 4) — its area is 25/2. Thus, the doubled area is 25. Two points that are on the same side are: (0, 1) and (0, 6).
solution: import javax.management.MBeanRegistration;
  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 ******************************************************
       ****************************************************************************************************************************/
      boolean[] sieve;
      public void solve() throws IOException {
          int t=ni();
  
          while (t-- > 0) {
              go();
          }
      }
  
      /********************************************************* MAIN LOGIC HERE ****************************************************/
  
      class Point {
          int x; int y;
          public Point(int x, int y) {
              this.x = x; this.y = y;
          }
      }
      public float area(Point A, Point B, Point C) {
          float area = (A.x * (B.y - C.y) + B.x * (C.y - A.y) + C.x * (A.y - B.y));
          return Math.abs(area);
      }
  
  
  
      public void go() throws IOException {
          long w=nl();
          long h=nl();
          long finalMax=Integer.MIN_VALUE;
          long min=Long.MAX_VALUE;
          long max=Long.MIN_VALUE;
          long n=nl();
          for(long i=0;i<n;i++){
              long p=nl();
              min=Math.min(p,min);
              max=Math.max(p,max);
          }
          long res=(max-min)*h;
          finalMax=Math.max(res,finalMax);
  
          min=Long.MAX_VALUE;
          max=Long.MIN_VALUE;
          n=nl();
          for(long i=0;i<n;i++){
              long p=ni();
              min=Math.min(p,min);
              max=Math.max(p,max);
          }
          res=(max-min)*h;
          finalMax=Math.max(res,finalMax);
  
          min=Long.MAX_VALUE;
          max=Long.MIN_VALUE;
          n=nl();
          for(long i=0;i<n;i++){
              long p=ni();
              min=Math.min(p,min);
              max=Math.max(p,max);
          }
          res=(max-min)*w;
          finalMax=Math.max(res,finalMax);
  
          min=Long.MAX_VALUE;
          max=Long.MIN_VALUE;
          n=nl();
          for(long i=0;i<n;i++){
              long p=ni();
              min=Math.min(p,min);
              max=Math.max(p,max);
          }
          res=(max-min)*w;
          finalMax=Math.max(res,finalMax);
  
          wr.println(finalMax);
  
      }
  }
  
  