A and B are preparing themselves for programming contests.

B loves to debug his code. But before he runs the solution and starts debugging, he has to first compile the code.

Initially, the compiler displayed n compilation errors, each of them is represented as a positive integer. After some effort, B managed to fix some mistake and then another one mistake.

However, despite the fact that B is sure that he corrected the two errors, he can not understand exactly what compilation errors disappeared — the compiler of the language which B uses shows errors in the new order every time! B is sure that unlike many other programming languages, compilation errors for his programming language do not depend on each other, that is, if you correct one error, the set of other error does not change.

Can you help B find out exactly what two errors he corrected?

Input

The first line of the input contains integer n (3 ≤ n ≤ 105) — the initial number of compilation errors.

The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the errors the compiler displayed for the first time. 

The third line contains n - 1 space-separated integers b1, b2, ..., bn - 1 — the errors displayed at the second compilation. It is guaranteed that the sequence in the third line contains all numbers of the second string except for exactly one. 

The fourth line contains n - 2 space-separated integers с1, с2, ..., сn - 2 — the errors displayed at the third compilation. It is guaranteed that the sequence in the fourth line contains all numbers of the third line except for exactly one. 

Output

Print two numbers on a single line: the numbers of the compilation errors that disappeared after B made the first and the second correction, respectively. 

Examples

Input

5
1 5 8 123 7
123 7 5 1
5 1 7


Output

8
123


Input

6
1 4 3 3 5 7
3 7 5 4 3
4 3 7 5


Output

1
3

Note

In the first test sample B first corrects the error number 8, then the error number 123.

In the second test sample B first corrects the error number 1, then the error number 3. Note that if there are multiple errors with the same number, B can correct only one of them in one step. 
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;
    }
}
