You have an array of integers (initially empty).

You have to perform q queries. Each query is of one of two types: 

  * "1 x" — add the element x to the end of the array; 
  * "2 x y" — replace all occurrences of x in the array with y. 



Find the resulting array after performing all the queries.

Input

The first line contains a single integer q (1 ≤ q ≤ 5 ⋅ 10^5) — the number of queries.

Next q lines contain queries (one per line). Each query is of one of two types: 

  * "1 x" (1 ≤ x ≤ 5 ⋅ 10^5); 
  * "2 x y" (1 ≤ x, y ≤ 5 ⋅ 10^5). 



It's guaranteed that there is at least one query of the first type.

Output

In a single line, print k integers — the resulting array after performing all the queries, where k is the number of queries of the first type.

Examples

Input


7
1 3
1 1
2 1 2
1 2
1 1
1 2
2 1 3


Output


3 2 2 3 2 

Input


4
1 1
1 2
1 1
2 2 2


Output


1 2 1 

Input


8
2 1 4
1 1
1 4
1 2
2 2 4
2 4 3
1 2
2 2 7


Output


1 3 3 7 

Note

In the first example, the array changes as follows:

[] → [3] → [3, 1] → [3, 2] → [3, 2, 2] → [3, 2, 2, 1] → [3, 2, 2, 1, 2] → [3, 2, 2, 3, 2].

In the second example, the array changes as follows:

[] → [1] → [1, 2] → [1, 2, 1] → [1, 2, 1].

In the third example, the array changes as follows:

[] → [] → [1] → [1, 4] → [1, 4, 2] → [1, 4, 4] → [1, 3, 3] → [1, 3, 3, 2] → [1, 3, 3, 7].
1
1 50
 1
1 114514
 1
1 2002
 1
1 500

50 
 114514 
 2002 
 500 

// HOPE

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////                                                                                                       //////////
///////                                                                                                       //////////
///////            RRRRRRRRRRRRR     YY          YY         AA               NN          NN                   //////////
///////            RR         RR      YY        YY        AA  AA             NN NN       NN                   //////////
///////            RR        RR         YY     YY        AA    AA            NN  NN      NN                   //////////
///////            RRRRRRRRRR            YY   YY       AAAAAAAAAAAA          NN    NN    NN                   //////////
///////            RR RR                   YY         AAAAAAAAAAAAAA         NN      NN  NN                   //////////
///////            RR   RR                 YY        AA            AA        NN       NN NN                   //////////
///////            RR     RR               YY       AA              AA       NN          NN                   //////////
///////            RR       RR_____________________________________________________________________________   //////////
////////                                                                                                      //////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.*;

public class Codeforces2 {
    static PrintWriter out = new PrintWriter(System.out);
    static final int mod=1_000_000_007;

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        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());
        }

        int[] readIntArray(int n){
            int[] a = new int[n];
            for(int i=0;i<n;i++)
                a[i] = nextInt();
            return a;
        }

        long[] readLongArray(int n){
            long[] a = new long[n];
            for(int i=0;i<n;i++)
                a[i] = nextLong();
            return a;
        }

        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;
        }
    }

    //Try seeing general case
    static int[] bottom, top, left, right;
    public static void main(String[] args)
    {
        FastReader s = new FastReader();
        int q = s.nextInt();
        HashMap<Integer, ArrayList<Integer>> hmp = new HashMap<>();
        int n = 0;
        while(q-->0)
        {
            int type = s.nextInt();
            if(type == 1)
            {
                int val = s.nextInt();
                ArrayList<Integer> ls1 = hmp.getOrDefault(val, new ArrayList<>());
                ls1.add(n);
                n++;
                hmp.put(val, ls1);
            }
            else
            {
                int val1 = s.nextInt();
                int val2 = s.nextInt();
                if(val1 == val2)
                    continue;

                ArrayList<Integer> ls1 = hmp.getOrDefault(val1, new ArrayList<>());
                ArrayList<Integer> ls2 = hmp.getOrDefault(val2, new ArrayList<>());

                hmp.remove(val1);
                hmp.remove(val2);

                if(ls1.size() < ls2.size())
                {
                    ls2.addAll(ls1);
                    hmp.put(val2,ls2);
                }
                else
                {
                    ls1.addAll(ls2);
                    hmp.put(val2,ls1);
                }
            }
        }

        int[] arr = new int[n];
        for(int val: hmp.keySet())
        {
            ArrayList<Integer> ls = hmp.get(val);
            for(Integer i: ls)
                arr[i] = val;
        }

        for(int x: arr)
            out.print(x+" ");
        out.println();



        out.close();
    }
























































































































    /////////////////////////////////////////////////THE END///////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public static int gcd(int x,int y)
    {
        return y==0?x:gcd(y,x%y);
    }
    public static long gcd(long x,long y)
    {
        return y==0L?x:gcd(y,x%y);
    }

    public static int lcm(int a, int b) {
        return (a * b) / gcd(a, b);
    }
    public static long lcm(long a, long b) {
        return (a * b) / gcd(a, b);
    }

    public static long pow(long a,long b)
    {
        if(b==0L)
            return 1L;
        long tmp=1;
        while(b>1L)
        {
            if((b&1L)==1)
                tmp*=a;
            a*=a;
            b>>=1;
        }
        return (tmp*a);
    }

    public static long modPow(long a,long b,long mod)
    {
        if(b==0L)
            return 1L;
        long tmp=1;
        while(b>1L)
        {
            if((b&1L)==1L)
                tmp*=a;

            a*=a;
            a%=mod;
            tmp%=mod;
            b>>=1;
        }
        return (tmp*a)%mod;
    }

    static long mul(long a, long b) {
        return a*b%mod;
    }

    static long fact(int n) {
        long ans=1;
        for (int i=2; i<=n; i++) ans=mul(ans, i);
        return ans;
    }

    static long fastPow(long base, long exp) {
        if (exp==0) return 1;
        long half=fastPow(base, exp/2);
        if (exp%2==0) return mul(half, half);
        return mul(half, mul(half, base));
    }

    static void debug(int ...a)
    {
        for(int x: a)
            out.print(x+" ");
        out.println();
    }

    static void debug(long ...a)
    {
        for(long x: a)
            out.print(x+" ");
        out.println();
    }

    static void debugMatrix(int[][] a)
    {
        for(int[] x:a)
            out.println(Arrays.toString(x));
    }
    static void debugMatrix(long[][] a)
    {
        for(long[] x:a)
            out.println(Arrays.toString(x));
    }

    static void reverseArray(int[] a) {
        int n = a.length;
        int[] arr = new int[n];
        for (int i = 0; i < n; i++)
            arr[i] = a[n - i - 1];
        for (int i = 0; i < n; i++)
            a[i] = arr[i];
    }

    static void reverseArray(long[] a) {
        int n = a.length;
        long[] arr = new long[n];
        for (int i = 0; i < n; i++)
            arr[i] = a[n - i - 1];
        for (int i = 0; i < n; i++)
            a[i] = arr[i];
    }

    static void sort(int[] a)
    {
        ArrayList<Integer> ls = new ArrayList<>();
        for(int x: a) ls.add(x);
        Collections.sort(ls);
        for(int i=0;i<a.length;i++)
            a[i] = ls.get(i);
    }

    static void sort(long[] a)
    {
        ArrayList<Long> ls = new ArrayList<>();
        for(long x: a) ls.add(x);
        Collections.sort(ls);
        for(int i=0;i<a.length;i++)
            a[i] = ls.get(i);
    }

    static class Pair{
        int x, y;
        Pair(int x, int y)
        {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "Pair{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }
    static class MyCmp implements Comparator<Pair>
    {
        public int compare(Pair p1, Pair p2)
        {
            return p1.x-p2.x;
        }
    }


}
