3
1 2 3
3 2
2
 3
84 30 9
9 84
9
 4
1 5 7 8
1 5 7
1 5
 3
796067435 964699482 819602309
964699482 796067435
964699482
 10
460626451 802090732 277246428 661369649 388684428 784303821 376287098 656422756 9301599 25720377
277246428 388684428 661369649 460626451 656422756 802090732 9301599 784303821 376287098
376287098 802090732 388684428 9301599 656422756 784303821 460626451 277246428
 6
5 4 3 3 5 5
3 5 5 4 3
3 5 4 3
 3
168638990 939116221 323703261
168638990 323703261
168638990
 3
77 77 77
77 77
77
 3
374054998 726316780 902899520
902899520 726316780
726316780

1
3
 30
84
 8
7
 819602309
796067435
 25720377
661369649
 5
5
 939116221
323703261
 77
77
 374054998
902899520

import java.util.*;
import java.io.*;
public class Test9 {
  
 public static void main(String[] args)
 {
  int n=Fs.nextInt();
  long[] a=Fs.nextLongArray(n);
  long[] b=Fs.nextLongArray(n-1);
  long[] c=Fs.nextLongArray(n-2);
  Arrays.sort(a);
  Arrays.sort(b);
  Arrays.sort(c);
  boolean flag=true;
  for(int i=0;i<n-1;i++){
   if(a[i]!=b[i]){
    flag=false;
    Fs.pl(a[i]);
    break;
   }
  }
  if(flag)Fs.pl(a[n-1]);
  flag=true;
  for(int i=0;i<n-2;i++){
   if(c[i]!=b[i]){
    flag=false;
    Fs.pl(b[i]);
    break;
   }
  }
  if(flag)Fs.pl(b[n-2]);
  Fs.flush();
 }

}
class Fs {
    private static final InputStream in = System.in;
    private static final byte[] buffer = new byte[1024];
    private static int ptr = 0;
    private static int buflen = 0;
    private static boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private static int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
    private static void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
    public static boolean hasNext() { skipUnprintable(); return hasNextByte();}
    public static String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public static int nextInt() {return (int)nextLong();}
    public static long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true){
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            }else if(b == -1 || !isPrintableChar(b)){
                return minus ? -n : n;
            }else{
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public static long[] nextLongArray(int i){
        long[] result=new long[i];
        for(int j=0;j<i;j++){
            result[j]=nextLong();
        }
        return result;
    }
    public static void nextLongArray(long[]... arrays){
        for(int j=0;j<arrays[0].length;j++){
            for(long[] array:arrays){
                array[j]=nextLong();
            }
        }
    }
    public static int[] nextIntArray(int i){
        int[] result=new int[i];
        for(int j=0;j<i;j++){
            result[j]=nextInt();
        }
        return result;
    }
    public static void nextIntArray(int[]... arrays){
        for(int j=0;j<arrays[0].length;j++){
            for(int[] array:arrays){
                array[j]=nextInt();
            }
        }
    }
    static StringBuilder sb=new StringBuilder();
    public static void flush(){
        System.out.print(sb);
        sb=new StringBuilder();
    }
    public static void pr(Object[] o,String str){
        for(Object ob:o){
            sb.append(ob);
            sb.append(str);
        }
    }
    public static void pr(long[] o,String str){
        for(long ob:o){
            sb.append(ob);
            sb.append(str);
        }
    }
    public static void pr(int[] o,String str){
        for(int ob:o){
            sb.append(ob);
            sb.append(str);
        }
    }
    public static void pr(double[] o,String str){
        for(double ob:o){
            sb.append(ob);
            sb.append(str);
        }
    }
    public static void pl(Object[] o,String str){
        pr(o,str);
        pl();
    }
    public static void pl(long[] o,String str){
        pr(o,str);
        pl();
    }
    public static void pl(int[] o,String str){
        pr(o,str);
        pl();
    }
    public static void pl(double[] o,String str){
        pr(o,str);
        pl();
    }
    public static void pr(Object o){
        sb.append(o);
    }
    public static void pl(Object o){
        sb.append(o);
        sb.append("\n");
    }
    public static void pr(long o){
        sb.append(o);
    }
    public static void pl(long o){
        sb.append(o);
        sb.append("\n");
    }
    public static void pr(double o){
        sb.append(o);
    }
    public static void pl(double o){
        sb.append(o);
        sb.append("\n");
    }
    public static void pl(){
        sb.append("\n");
    }
    public static long[] prefSum(long[] la){
        long[] result=new long[la.length];
        long l=0;
        for(int i=0;i<la.length;i++){
            result[i]=l+la[i];
            l=result[i];
        }
        return result;
    }
    public static long[] prefSum(long[] la,long mod){
        long[] result=new long[la.length];
        long l=0;
        for(int i=0;i<la.length;i++){
            result[i]=(l+la[i]+mod)%mod;
            l=result[i];
        }
        return result;
    }
    public static int lastLowerIndex(long[] array,long lo){//array is sorted.
        if(array[array.length-1]<lo){return array.length-1;}
        if(array[0]>=lo){return -1;}
        int tmax=array.length-1;
        int tmin=0;
        int haba=tmax-tmin;
        int tindex=tmin+haba/2;
        while(haba>0){
            if(array[tindex]<lo){
                tmin=tindex;
            }else{
                tmax=tindex-1;
            }
            haba=tmax-tmin;
            tindex=tmin+haba/2+(haba==1?1:0);
        }
        return tindex;
    }
    public static int lastLowerOrEqualIndex(long[] array,long lo){
        if(array[array.length-1]<=lo){return array.length-1;}
        if(array[0]>lo){return -1;}
        int tmax=array.length-1;
        int tmin=0;
        int haba=tmax-tmin;
        int tindex=tmin+haba/2;
        while(haba>0){
            if(array[tindex]<=lo){
                tmin=tindex;
            }else{
                tmax=tindex-1;
            }
            haba=tmax-tmin;
            tindex=tmin+haba/2+(haba==1?1:0);
        }
        return tindex;
    }
    public static long modPow(long a,long b,long mod){
        long c=1;
        while(b>0){
            if(b%2==1){
                c=(c*a)%mod;
            }
            a=(a*a)%mod;
            b/=2;
        }
        return c;
    }
    public static long inv(long a,long mod){
       long b=mod;
       long p = 1, q = 0;
		while (b > 0) {
			long c = a / b;
			long d;
			d = a;
			a = b;
			b = d % b;
			d = p;
			p = q;
			q = d - c * q;
		}
		return p < 0 ? p + mod : p;
    }
}
