description: There is a city that can be represented as a square grid with corner points in (0, 0) and (10^6, 10^6).
  
  The city has n vertical and m horizontal streets that goes across the whole city, i. e. the i-th vertical streets goes from (x_i, 0) to (x_i, 10^6) and the j-th horizontal street goes from (0, y_j) to (10^6, y_j). 
  
  All streets are bidirectional. Borders of the city are streets as well.
  
  There are k persons staying on the streets: the p-th person at point (x_p, y_p) (so either x_p equal to some x_i or y_p equal to some y_j, or both).
  
  Let's say that a pair of persons form an inconvenient pair if the shortest path from one person to another going only by streets is strictly greater than the Manhattan distance between them.
  
  Calculate the number of inconvenient pairs of persons (pairs (x, y) and (y, x) are the same pair).
  
  Let's recall that Manhattan distance between points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2|.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
  
  The first line of each test case contains three integers n, m and k (2 ≤ n, m ≤ 2 ⋅ 10^5; 2 ≤ k ≤ 3 ⋅ 10^5) — the number of vertical and horizontal streets and the number of persons.
  
  The second line of each test case contains n integers x_1, x_2, ..., x_n (0 = x_1 < x_2 < ... < x_{n - 1} < x_n = 10^6) — the x-coordinates of vertical streets.
  
  The third line contains m integers y_1, y_2, ..., y_m (0 = y_1 < y_2 < ... < y_{m - 1} < y_m = 10^6) — the y-coordinates of horizontal streets.
  
  Next k lines contains description of people. The p-th line contains two integers x_p and y_p (0 ≤ x_p, y_p ≤ 10^6; x_p ∈ \\{x_1, ..., x_n\} or y_p ∈ \\{y_1, ..., y_m\}) — the coordinates of the p-th person. All points are distinct.
  
  It guaranteed that sum of n doesn't exceed 2 ⋅ 10^5, sum of m doesn't exceed 2 ⋅ 10^5 and sum of k doesn't exceed 3 ⋅ 10^5.
  
  Output
  
  For each test case, print the number of inconvenient pairs.
  
  Example
  
  Input
  
  
  2
  2 2 4
  0 1000000
  0 1000000
  1 0
  1000000 1
  999999 1000000
  0 999999
  5 4 9
  0 1 2 6 1000000
  0 4 8 1000000
  4 4
  2 5
  2 2
  6 3
  1000000 1
  3 8
  5 8
  8 8
  6 8
  
  
  Output
  
  
  2
  5
  
  Note
  
  The second test case is pictured below: 
  
  <image>
  
  For example, points 3 and 4 form an inconvenient pair, since the shortest path between them (shown red and equal to 7) is greater than its Manhattan distance (equal to 5).
  
  Points 3 and 5 also form an inconvenient pair: the shortest path equal to 1000001 (shown green) is greater than the Manhattan distance equal to 999999.
  
  But points 5 and 9 don't form an inconvenient pair, since the shortest path (shown purple) is equal to its Manhattan distance.
solution: #!/usr/bin/env python3
  import sys
  import getpass  # not available on codechef
  from collections import Counter
  input = sys.stdin.readline  # to read input quickly
  
  # available on Google, AtCoder Python3, not available on Codeforces
  # import numpy as np
  # import scipy
  
  M9 = 10**9 + 7  # 998244353
  yes, no = "YES", "NO"
  # d4 = [(1,0),(0,1),(-1,0),(0,-1)]
  # d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
  # d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)]  # hexagonal layout
  MAXINT = sys.maxsize
  
  # if testing locally, print to terminal with a different color
  OFFLINE_TEST = getpass.getuser() == "hkmac"
  # OFFLINE_TEST = False  # codechef does not allow getpass
  def log(*args):
      if OFFLINE_TEST:
          print('\033[36m', *args, '\033[0m', file=sys.stderr)
  
  def solve(*args):
      # screen input
      if OFFLINE_TEST:
          log("----- solving ------")
          log(*args)
          log("----- ------- ------")
      return solve_(*args)
  
  def read_matrix(rows):
      return [list(map(int,input().split())) for _ in range(rows)]
  
  def read_strings(rows):
      return [input().strip() for _ in range(rows)]
  
  def minus_one(arr):
      return [x-1 for x in arr]
  
  def minus_one_matrix(mrr):
      return [[x-1 for x in row] for row in mrr]
  
  # ---------------------------- template ends here ----------------------------
  
  
  import os
  from io import BytesIO, IOBase
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  
  LARGE = 10**7
  
  
  def solve_():
      n,m,k = list(map(int,input().split()))
      xrr = list(map(int,input().split()))
      yrr = list(map(int,input().split()))
      # your solution here
  
      # include/exclude pairs on the same street
      # include pairs of different streets
  
      xset = set(xrr)
      yset = set(yrr)
  
      xset.add(-1)
      xset.add(LARGE)
      yset.add(-1)
      yset.add(LARGE)
  
      arr = [(y,-1) for y in yrr]
      brr = [(x,-1) for x in xrr]
  
      del xrr
      del yrr
  
      mrr = read_matrix(k)  # and return as a list of list of int
      for x,y in mrr:
          # exclude all people staying on horizontal and vertical street
          if x in xset and y in yset:
              continue
  
          if x in xset:
              arr.append((y,x))
  
          if y in yset:
              brr.append((x,y))
  
      del xset
      del yset
      del mrr
  
      arr.sort(key=lambda x: x[0])
      brr.sort(key=lambda x: x[0])
  
      # log(arr)
      # log(brr)
  
      res = 0
  
      cnt = 0
      cntr = Counter()
      for y,x in arr:
          if x == -1:
              cnt = 0
              cntr = Counter()
          else:
              res += cnt
              res -= cntr[x]
              cnt += 1
              cntr[x] += 1
  
      cnt = 0
      cntr = Counter()
      for x,y in brr:
          if y == -1:
              cnt = 0
              cntr = Counter()
          else:
              res += cnt
              res -= cntr[y]
              cnt += 1
              cntr[y] += 1
  
      return res
  
  
  # for case_num in [0]:  # no loop over test case
  # for case_num in range(100):  # if the number of test cases is specified
  for case_num in range(int(input())):
  
      # read line as an integer
      # k = int(input())
  
      # read line as a string
      # srr = input().strip()
  
      # read one line and parse each word as a string
      # lst = input().split()
  
      # read one line and parse each word as an integer
      # lst = minus_one(lst)
  
      # read multiple rows
      # xrr = read_strings(k)  # and return as a list of str
      # yrr = read_strings(k)  # and return as a list of str
      # mrr = minus_one_matrix(mrr)
  
      res = solve()  # include input here
  
      # print length if applicable
      # print(len(res))
  
      # parse result
      # res = " ".join(str(x) for x in res)
      # res = "\n".join(str(x) for x in res)
      # res = "\n".join(" ".join(str(x) for x in row) for row in res)
  
      # print result
      # print("Case #{}: {}".format(case_num+1, res))   # Google and Facebook - case number required
  
      print(res)