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 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    static int mod = (int) (1e9) + 7;

    /* ======================DSU===================== */
    static class dsu {
        static int parent[], n;// min[],value[];
        static long size[];

        dsu(int n) {
            parent = new int[n + 1];
            size = new long[n + 1];
            // min=new int[n+1];
            // value=new int[n+1];
            Main.dsu.n = n;
            makeSet();
        }

        static void makeSet() {
            for (int i = 1; i <= n; i++) {
                parent[i] = i;
                size[i] = 1;
                // min[i]=i;
            }
        }

        static int find(int a) {
            if (parent[a] == a)
                return a;
            else {
                return parent[a] = find(parent[a]);// Path Compression
            }
        }

        static void union(int a, int b) {
            int setA = find(a);
            int setB = find(b);
            if (setA == setB)
                return;
            if (size[setA] >= size[setB]) {
                parent[setB] = setA;
                size[setA] += size[setB];
            } else {
                parent[setA] = setB;
                size[setB] += size[setA];
            }
        }
    }

    /* ======================================================== */
    static class Pair<X extends Number, Y extends Number> implements Comparator<Pair> {
        X x;
        Y y;

        // Constructor
        public Pair(X x, Y y) {
            this.x = x;
            this.y = y;
        }

        public Pair() {

        }

        @Override
        public int compare(Main.Pair o1, Main.Pair o2) {
            return ((int) (o1.y.intValue() - o2.y.intValue()));// Ascending Order based on 'y'
        }
    }

    /* ===============================Tries================================= */
    static class TrieNode {
        private HashMap<Character, TrieNode> children = new HashMap<>();
        public int size;
        boolean endOfWord;

        public void putChildIfAbsent(char ch) {
            children.putIfAbsent(ch, new TrieNode());
        }

        public TrieNode getChild(char ch) {
            return children.get(ch);
        }
    }

    static private TrieNode root;

    public static void insert(String str) {
        TrieNode curr = root;
        for (char ch : str.toCharArray()) {
            curr.putChildIfAbsent(ch);
            curr = curr.getChild(ch);
            curr.size++;
        }
        // mark the current nodes endOfWord as true
        curr.endOfWord = true;
    }

    public static int search(String word) {
        TrieNode curr = root;

        for (char ch : word.toCharArray()) {
            curr = curr.getChild(ch);
            if (curr == null) {
                return 0;
            }
        }
        // size contains words starting with prefix- word
        return curr.size;
    }

    public boolean delete(TrieNode current, String word, int index) {
        if (index == word.length()) {
            // when end of word is reached only delete if currrent.endOfWord is true.
            if (!current.endOfWord) {
                return false;
            }
            current.endOfWord = false;
            // if current has no other mapping then return true
            return current.children.size() == 0;
        }
        char ch = word.charAt(index);
        TrieNode node = current.children.get(ch);
        if (node == null) {
            return false;
        }
        boolean shouldDeleteCurrentNode = delete(node, word, index + 1);

        // if true is returned then delete the mapping of character and trienode
        // reference from map.
        if (shouldDeleteCurrentNode) {
            current.children.remove(ch);
            // return true if no mappings are left in the map.
            return current.children.size() == 0;
        }
        return false;
    }

    /* ================================================================= */

    static boolean isPrime(long n) {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
        if (n % 2 == 0 || n % 3 == 0)
            return false;
        for (long i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;
        return true;
    }

    static Pair<Integer, Integer> lowerBound(long[] a, long x) { // x is the target, returns lowerBound. If not found
                                                                 // return -1
        int l = -1, r = a.length;
        while (l + 1 < r) {
            int m = (l + r) >>> 1;
            if (a[m] == x) {
                return new Pair<>(m, 1);
            }
            if (a[m] >= x)
                r = m;
            else
                l = m;
        }
        return new Pair<>(r, 0);
    }

    static Pair<Integer, Integer> upperBound(long[] a, long x) {// x is the target, returns upperBound. If not found
        int l = -1, r = a.length;
        while (l + 1 < r) {
            int m = (l + r) >>> 1;
            if (a[m] == x) {
                return new Pair<>(m, 1);
            }
            if (a[m] <= x)
                l = m;
            else
                r = m;
        }
        return new Pair<>(l + 1, 0);
    }

    static long gcd(long a, long b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

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

    static long power(long x, long y) {
        long res = 1;
        while (y > 0) {
            if (y % 2 == 1)
                res = (res * x);
            y >>= 1;
            x = (x * x);
        }
        return res;
    }

    public double binPow(double x, int n) {// binary exponentiation with negative power as well
        if (n == 0)
            return 1.0;
        double binPow = binPow(x, n / 2);
        if (n % 2 == 0) {
            return binPow * binPow;
        } else {
            return n > 0 ? (binPow * binPow * x) : (binPow * binPow / x);
        }
    }

    static long ceil(long x, long y) {
        return (x % y == 0 ? x / y : (x / y + 1));
    }

    /*
     * ===========Modular Operations==================
     */
    static long modPower(long x, long y, long p) {
        long res = 1;
        x = x % p;
        while (y > 0) {
            if (y % 2 == 1)
                res = (res * x) % p;
            y = y >> 1; // y = y/2
            x = (x * x) % p;
        }
        return res;
    }

    static long modInverse(long n, long p) {
        return modPower(n, p - 2, p);
    }

    static long modAdd(long a, long b) {
        return ((a + b + mod) % mod);
    }

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

    static long[] fac = new long[200000 + 5];
    static long[] invFac = new long[200000 + 5];

    static long nCrModPFermat(int n, int r) {
        if (r == 0)
            return 1;
        // return (fac[n] * modInverse(fac[r], mod) % mod * modInverse(fac[n - r], mod)
        // % mod) % mod;
        return (fac[n] * invFac[r] % mod * invFac[n - r] % mod) % mod;
    }

    /*
     * ===============================================
     */

    static void ruffleSort(long[] a) {
        int n = a.length;
        Random r = new Random();
        for (int i = 0; i < a.length; i++) {
            int oi = r.nextInt(n);
            long temp = a[i];
            a[i] = a[oi];
            a[oi] = temp;
        }
        Arrays.sort(a);
    }

    static void ruffleSort(int[] a) {
        int n = a.length;
        Random r = new Random();
        for (int i = 0; i < a.length; i++) {
            int oi = r.nextInt(n);
            int temp = a[i];
            a[i] = a[oi];
            a[oi] = temp;
        }
        Arrays.sort(a);
    }

    static boolean isVowel(char ch) {
        return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
    }

    static String binString32(int n) {
        StringBuilder str = new StringBuilder("");
        String bin = Integer.toBinaryString(n);
        if (bin.length() != 32) {
            for (int k = 0; k < 32 - bin.length(); k++) {
                str.append("0");
            }
            str.append(bin);
        }
        return str.toString();
    }

    static class sparseTable {
        public static int st[][];
        public static int log = 4;

        static int func(int a, int b) {// make func as per question(here min range query)
            return (int) gcd(a, b);
        }

        void makeTable(int n, int a[]) {

            st = new int[n][log];
            for (int i = 0; i < n; i++) {
                st[i][0] = a[i];
            }
            for (int j = 1; j < log; j++) {
                for (int i = 0; i + (1 << j) <= n; i++) {
                    st[i][j] = func(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
                }
            }
        }

        static int query(int l, int r) {
            int length = r - l + 1;
            int k = 0;
            while ((1 << (k + 1)) <= length) {
                k++;
            }
            return func(st[l][k], st[r - (1 << k) + 1][k]);
        }

        static void printTable(int n) {
            for (int j = 0; j < log; j++) {
                for (int i = 0; i < n; i++) {
                    System.out.print(st[i][j] + " ");
                }
                System.out.println();
            }
        }
    }

    /*
     * ====================================Main=================================
     */

    // static int st[], a[];

    // static void buildTree(int treeIndex, int lo, int hi) {
    // if (hi == lo) {
    // st[treeIndex] = a[lo];
    // return;
    // }
    // int mid = (lo + hi) / 2;
    // buildTree(treeIndex * 2 + 1, lo, mid);
    // buildTree(treeIndex * 2 + 2, mid + 1, hi);
    // st[treeIndex] = merge(st[treeIndex * 2 + 1], st[treeIndex * 2 + 2]);
    // }

    // static void update(int treeIndex, int lo, int hi, int arrIndex, int val) {
    // if (hi == lo) {
    // st[treeIndex] = val;
    // a[arrIndex] = val;
    // return;
    // }
    // int mid = (hi + lo) / 2;
    // if (mid < arrIndex) {
    // update(treeIndex * 2 + 2, mid + 1, hi, arrIndex, val);
    // } else {
    // update(treeIndex * 2 + 1, lo, mid, arrIndex, val);
    // }
    // st[treeIndex] = merge(st[treeIndex * 2 + 1], st[treeIndex * 2 + 2]);
    // }

    // static int query(int treeIndex, int lo, int hi, int l, int r) {
    // if (l <= lo && r >= hi) {
    // return st[treeIndex];
    // }
    // if (l > hi || r < lo) {
    // return 0;
    // }
    // int mid = (hi + lo) / 2;
    // return query(treeIndex * 2 + 1, lo, mid, l, Math.min(mid, r));
    // }

    // static int merge(int a, int b) {
    // return a + b;
    // }

    public static long findKthPositive(long[] A, long k) {
        int l = 0, r = A.length, m;
        while (l < r) {
            m = (l + r) / 2;
            if (A[m] - 1 - m < k)
                l = m + 1;
            else
                r = m;
        }
        return l + k;
    }

    static int[] z_function(char ar[]) {
        int[] z = new int[ar.length];
        z[0] = ar.length;
        int l = 0;
        int r = 0;
        for (int i = 1; i < ar.length; i++) {
            if (r < i) {
                l = i;
                r = i;
                while (r < ar.length && ar[r - l] == ar[r])
                    r++;
                z[i] = r - l;
                r--;
            } else {
                int k = i - l;
                if (z[k] < r - i + 1) {
                    z[i] = z[k];
                } else {
                    l = i;
                    while (r < ar.length && ar[r - l] == ar[r])
                        r++;
                    z[i] = r - l;
                    r--;
                }
            }
        }
        return z;
    }

    static void mergeSort(int a[]) {
        int n = a.length;
        if (n >= 2) {
            int mid = n / 2;
            int left[] = new int[mid];
            int right[] = new int[n - mid];
            for (int i = 0; i < mid; i++) {
                left[i] = a[i];
            }
            for (int i = mid; i < n; i++) {
                right[i - mid] = a[i];
            }
            mergeSort(left);
            mergeSort(right);
            mergeSortedArray(left, right, a);
        }
    }

    static void mergeSortedArray(int left[], int right[], int a[]) {
        int i = 0, j = 0, k = 0, n = left.length, m = right.length;
        while (i != n && j != m) {
            if (left[i] < right[j]) {
                a[k++] = left[i++];
            } else {
                a[k++] = right[j++];
            }
        }
        while (i != n) {
            a[k++] = left[i++];
        }
        while (j != m) {
            a[k++] = right[j++];
        }
    }

    // BINARY SEARCH
    // count of set bits in a particular position
    // suffix max array/ suffix sum array/ prefix
    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());
        }

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

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

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

    static FastReader f = new FastReader();
    static BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
    static ArrayList<String> strArr = new ArrayList<>();

    public static void main(String args[]) throws Exception {
        int t = 1;
        // t = f.nextInt();
        int tc = 1;
        Main ob = new Main() {
        };
        // fac[0] = 1;
        // for (int i = 1; i <= 200000; i++) {
        // fac[i] = fac[i - 1] * i % mod;
        // invFac[i] = modInverse(fac[i], mod);
        // }
        while (t-- != 0) {
            int q = f.nextInt();
            HashMap<Integer, StringBuilder> hm = new HashMap<>();
            ArrayList<Integer> ar=new ArrayList<>();
            int choices[][]=new int[q][3];
            int val[]=new int[5*100000+1];
            for(int i=1;i<=500000;i++){
                val[i]=i;
            }
            int pos = 0;
            for(int i=0;i<q;i++){
                int choice = f.nextInt();
                if (choice == 1) {
                    int x = f.nextInt();
                    choices[i][0]=choice;
                    choices[i][1]=x;
                    choices[i][2]=-1;
                    pos++;
                } else {
                    int x = f.nextInt();
                    int y = f.nextInt();
                    choices[i][0]=-1;
                    if(pos>0){
                        choices[i][0]=choice;
                        choices[i][1]=x;
                        choices[i][2]=y;
                    }
                    
                }
            }
            for(int i=q-1;i>=0;i--){
                if(choices[i][0]==1){
                    ar.add(val[choices[i][1]]);
                }else if(choices[i][0]==2){
                    val[choices[i][1]]=val[choices[i][2]];
                }
            }
            for(int i=pos-1;i>=0;i--){
                w.write(ar.get(i)+" ");
            }
            w.write("\n");
        }
        w.flush();
    }
}
/*

 */