output_description: Print the number of different altars that Ringo can build.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      A_1 ... A_N
      B_1 ... B_N
      C_1 ... C_N
attempt: # -*- coding: utf-8 -*-
  
  #############
  # Libraries #
  #############
  
  import sys
  
  input = sys.stdin.readline
  
  import math
  
  # from math import gcd
  import bisect
  from collections import defaultdict
  from collections import deque
  from functools import lru_cache
  
  
  #############
  # Constants #
  #############
  
  MOD = 10**9 + 7
  INF = float("inf")
  
  #############
  # Functions #
  #############
  
  
  ######INPUT######
  def I():
      return int(input().strip())
  
  
  def S():
      return input().strip()
  
  
  def IL():
      return list(map(int, input().split()))
  
  
  def SL():
      return list(map(str, input().split()))
  
  
  def ILs(n):
      return list(int(input()) for _ in range(n))
  
  
  def SLs(n):
      return list(input().strip() for _ in range(n))
  
  
  def ILL(n):
      return [list(map(int, input().split())) for _ in range(n)]
  
  
  def SLL(n):
      return [list(map(str, input().split())) for _ in range(n)]
  
  
  ######OUTPUT######
  def P(arg):
      print(arg)
      return
  
  
  def Y():
      print("Yes")
      return
  
  
  def N():
      print("No")
      return
  
  
  def E():
      exit()
  
  
  def PE(arg):
      print(arg)
      exit()
  
  
  def YE():
      print("Yes")
      exit()
  
  
  def NE():
      print("No")
      exit()
  
  
  #####Shorten#####
  def DD(arg):
      return defaultdict(arg)
  
  
  #####Inverse#####
  def inv(n):
      return pow(n, MOD - 2, MOD)
  
  
  ######Combination######
  kaijo_memo = []
  
  
  def kaijo(n):
      if len(kaijo_memo) > n:
          return kaijo_memo[n]
      if len(kaijo_memo) == 0:
          kaijo_memo.append(1)
      while len(kaijo_memo) <= n:
          kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
      return kaijo_memo[n]
  
  
  gyaku_kaijo_memo = []
  
  
  def gyaku_kaijo(n):
      if len(gyaku_kaijo_memo) > n:
          return gyaku_kaijo_memo[n]
      if len(gyaku_kaijo_memo) == 0:
          gyaku_kaijo_memo.append(1)
      while len(gyaku_kaijo_memo) <= n:
          gyaku_kaijo_memo.append(
              gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo), MOD - 2, MOD) % MOD
          )
      return gyaku_kaijo_memo[n]
  
  
  def nCr(n, r):
      if n == r:
          return 1
      if n < r or r < 0:
          return 0
      ret = 1
      ret = ret * kaijo(n) % MOD
      ret = ret * gyaku_kaijo(r) % MOD
      ret = ret * gyaku_kaijo(n - r) % MOD
      return ret
  
  
  ######Factorization######
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-(n**0.5) // 1)) + 1):
          if temp % i == 0:
              cnt = 0
              while temp % i == 0:
                  cnt += 1
                  temp //= i
              arr.append([i, cnt])
      if temp != 1:
          arr.append([temp, 1])
      if arr == []:
          arr.append([n, 1])
      return arr
  
  
  #####MakeDivisors######
  def make_divisors(n):
      divisors = []
      for i in range(1, int(n**0.5) + 1):
          if n % i == 0:
              divisors.append(i)
              if i != n // i:
                  divisors.append(n // i)
      return divisors
  
  
  #####GCD#####
  def gcd(a, b):
      while b:
          a, b = b, a % b
      return a
  
  
  #####LCM#####
  def lcm(a, b):
      return a * b // gcd(a, b)
  
  
  #####BitCount#####
  def count_bit(n):
      count = 0
      while n:
          n &= n - 1
          count += 1
      return count
  
  
  #####ChangeBase#####
  def base_10_to_n(X, n):
      if X // n:
          return base_10_to_n(X // n, n) + [X % n]
      return [X % n]
  
  
  def base_n_to_10(X, n):
      return sum(int(str(X)[-i - 1]) * n**i for i in range(len(str(X))))
  
  
  #####IntLog#####
  def int_log(n, a):
      count = 0
      while n >= a:
          n //= a
          count += 1
      return count
  
  
  #############
  # Main Code #
  #############
  
  N = I()
  A, B, C = ILL(3)
  A.sort()
  B.sort()
  C.sort()
  
  B2 = []
  
  for b in B:
      p = bisect.bisect_left(A, b)
      if B2 == []:
          B2.append(p)
      else:
          B2.append(B2[-1] + p)
  
  C2 = []
  for i in range(N):
      c = C[i]
      p = bisect.bisect_left(B, c)
      if C2 == []:
          if p == 0:
              C2.append(0)
          else:
              C2.append(B2[p - 1])
      else:
          if p == 0:
              C2.append(C2[-1])
          else:
              C2.append(C2[-1] + B2[p - 1])
  print(C2[-1])
  
problem_description: Statement
  
  The season for Snuke Festival has come again this year. First of all, Ringo
  will perform a ritual to summon Snuke. For the ritual, he needs an altar,
  which consists of three parts, one in each of the three categories: upper,
  middle and lower.
  
  He has N parts for each of the three categories. The size of the i-th upper
  part is A_i, the size of the i-th middle part is B_i, and the size of the i-th
  lower part is C_i.
  
  To build an altar, the size of the middle part must be strictly greater than
  that of the upper part, and the size of the lower part must be strictly
  greater than that of the middle part. On the other hand, any three parts that
  satisfy these conditions can be combined to form an altar.
  
  How many different altars can Ringo build? Here, two altars are considered
  different when at least one of the three parts used is different.
samples: [{"input": "2\n    1 5\n    2 4\n    3 6", "output": "3\n    \n\nThe following three altars can be built:\n\n  * Upper: 1-st part, Middle: 1-st part, Lower: 1-st part\n  * Upper: 1-st part, Middle: 1-st part, Lower: 2-nd part\n  * Upper: 1-st part, Middle: 2-nd part, Lower: 2-nd part\n\n* * *"}, {"input": "3\n    1 1 1\n    2 2 2\n    3 3 3", "output": "27\n    \n\n* * *"}, {"input": "6\n    3 14 159 2 6 53\n    58 9 79 323 84 6\n    2643 383 2 79 50 288", "output": "87"}]