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.util.*;
import java.lang.*;
import java.rmi.ConnectIOException;
import java.io.*;

public class Main {
    static FastReader in;
    static PrintWriter out;

    static int bit(long n) {
        return (n == 0) ? 0 : (1 + bit(n & (n - 1)));
    }

    static void p(Object o) {
        out.print(o);
    }

    static void pn(Object o) {
        out.println(o);
    }

    static void pni(Object o) {
        out.println(o);
        out.flush();
    }

    static String n() throws Exception {
        return in.next();
    }

    static String nln() throws Exception {
        return in.nextLine();
    }

    static int ni() throws Exception {
        return Integer.parseInt(in.next());
    }

    static long nl() throws Exception {
        return Long.parseLong(in.next());
    }

    static double nd() throws Exception {
        return Double.parseDouble(in.next());
    }

    static class FastReader {
        static BufferedReader br;
        static StringTokenizer st;

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

        public FastReader(String s) throws Exception {
            br = new BufferedReader(new FileReader(s));
        }

        String next() throws Exception {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new Exception(e.toString());
                }
            }
            return st.nextToken();
        }

        String nextLine() throws Exception {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                throw new Exception(e.toString());
            }
            return str;
        }
    }

    static long power(long a, long b) {
        if (b == 0)
            return 1;
        long val = power(a, b / 2);
        val = val * val;
        if ((b % 2) != 0)
            val = val * a;
        return val;
    }

    static long power(long a, long b, long mod) {
        if (b == 0)
            return 1L;
        long val = power(a, b / 2) % mod;
        val = (val * val) % mod;
        if ((b % 2) != 0)
            val = (val * a) % mod;
        return val % mod;
    }

    static ArrayList<Long> prime_factors(long n) {
        ArrayList<Long> ans = new ArrayList<Long>();
        while (n % 2 == 0) {
            ans.add(2L);
            n /= 2L;
        }
        for (long i = 3; i <= Math.sqrt(n); i++) {
            while (n % i == 0) {
                ans.add(i);
                n /= i;
            }
        }
        if (n > 2) {
            ans.add(n);
        }
        return ans;
    }

    static void sort(ArrayList<Long> a) {
        Collections.sort(a);
    }

    static void reverse_sort(ArrayList<Long> a) {
        Collections.sort(a, Collections.reverseOrder());
    }

    static void swap(long[] a, int i, int j) {
        long temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    static void swap(List<Long> a, int i, int j) {
        long temp = a.get(i);
        a.set(j, a.get(i));
        a.set(j, temp);
    }

    static void sieve(boolean[] prime) {
        int n = prime.length - 1;
        Arrays.fill(prime, true);
        for (int i = 2; i * i <= n; i++) {
            if (prime[i]) {
                for (int j = 2 * i; j <= n; j += i) {
                    prime[j] = false;
                }
            }
        }
    }

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

    static long mod = 1000000007;

    public static void sort(long[] arr, int l, int r) {
        if (l >= r)
            return;
        int mid = (l + r) / 2;
        sort(arr, l, mid);
        sort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    public static void sort(int[] arr, int l, int r) {
        if (l >= r)
            return;
        int mid = (l + r) / 2;
        sort(arr, l, mid);
        sort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    static void merge(int[] arr, int l, int mid, int r) {
        int[] left = new int[mid - l + 1];
        int[] right = new int[r - mid];
        for (int i = l; i <= mid; i++) {
            left[i - l] = arr[i];
        }
        for (int i = mid + 1; i <= r; i++) {
            right[i - (mid + 1)] = arr[i];
        }
        int left_start = 0;
        int right_start = 0;
        int left_length = mid - l + 1;
        int right_length = r - mid;
        int temp = l;
        while (left_start < left_length && right_start < right_length) {
            if (left[left_start] < right[right_start]) {
                arr[temp] = left[left_start++];
            } else {
                arr[temp] = right[right_start++];
            }
            temp++;
        }
        while (left_start < left_length) {
            arr[temp++] = left[left_start++];
        }
        while (right_start < right_length) {
            arr[temp++] = right[right_start++];
        }
    }

    static void merge(long[] arr, int l, int mid, int r) {
        long[] left = new long[mid - l + 1];
        long[] right = new long[r - mid];
        for (int i = l; i <= mid; i++) {
            left[i - l] = arr[i];
        }
        for (int i = mid + 1; i <= r; i++) {
            right[i - (mid + 1)] = arr[i];
        }
        int left_start = 0;
        int right_start = 0;
        int left_length = mid - l + 1;
        int right_length = r - mid;
        int temp = l;
        while (left_start < left_length && right_start < right_length) {
            if (left[left_start] < right[right_start]) {
                arr[temp] = left[left_start++];
            } else {
                arr[temp] = right[right_start++];
            }
            temp++;
        }
        while (left_start < left_length) {
            arr[temp++] = left[left_start++];
        }
        while (right_start < right_length) {
            arr[temp++] = right[right_start++];
        }
    }

    static class pair implements Comparable<pair> {
        int a, b;

        public pair(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public int compareTo(pair p) {
            return this.a - p.a;
        }

    }

    static HashMap<Long, Integer> map_prime_factors(long n) {
        HashMap<Long, Integer> map = new HashMap<>();
        while (n % 2 == 0) {
            map.put(2L, map.getOrDefault(2L, 0) + 1);
            n /= 2L;
        }
        for (long i = 3; i <= Math.sqrt(n); i++) {
            while (n % i == 0) {
                map.put(i, map.getOrDefault(i, 0) + 1);
                n /= i;
            }
        }
        if (n > 2) {
            map.put(n, map.getOrDefault(n, 0) + 1);
        }
        return map;
    }

    static int count = 1;
    static int[] p = new int[100002];
    static long[] flat_tree = new long[300002];
    static int[] in_time = new int[1000002];
    static int[] out_time = new int[1000002];
    static long[] subtree_gcd = new long[100002];
    static int w = 0;
    static boolean poss = true;

    public static void main(String[] args) throws Exception {
        in = new FastReader();
        out = new PrintWriter(System.out);
        int t = ni();
        List<List<Integer>> arr = new ArrayList<>();
        for (int i = 0; i < 500001; i++)
            arr.add(i, new ArrayList<>());
        int n = 0;
        while (t-- > 0) {
            int type = ni();
            int x = ni();
            if (type == 1) {
                arr.get(x).add(n++);
            } else {
                int y = ni();
                if (x == y)
                    continue;
                if (arr.get(x).size() > arr.get(y).size()) {
                    List<Integer> temp = arr.get(x);
                    arr.set(x, arr.get(y));
                    arr.set(y, temp);
                }
                for (int val : arr.get(x)) {
                    arr.get(y).add(val);
                }
                arr.get(x).clear();
            }

            // int a = ni();
            // int b = ni();
            // String s = n();
            // int n = s.length();
            // if (n == 1) {
            // if (s.charAt(0) == '0')
            // pn("0");
            // else
            // pn(a);
            // continue;
            // }
            // int count = 0;
            // int between = 0;
            // if (s.charAt(0) == '1')
            // count++;
            // for (int i = 1; i < n; i++) {
            // if (s.charAt(i) == '1' && s.charAt(i) != s.charAt(i - 1))
            // count++;
            // }
            // for (int i = 1; i < n - 1; i++) {
            // if (s.charAt(i) == '0' && s.charAt(i - 1) == '1' && s.charAt(i + 1) == '1')
            // between++;
            // }
            // pn(Math.min(count*a,between * b + (count - between) * a));
        }
        int[] ans = new int[n];
        for (int i = 0; i < 50001; i++) {
            for (int index : arr.get(i)) {
                ans[index] = i;
            }
        }
        for (int i = 0; i < n; i++)
            p(ans[i] + " ");
        pn("");
        out.flush();
        out.close();
    }

    static void find(int l, int r, int level, int[] arr, int[] depth) {
        if (r < l)
            return;
        int max = find(l, r, arr);
        depth[max] = level;
        find(l, max - 1, level + 1, arr, depth);
        find(max + 1, r, level + 1, arr, depth);
    }

    static int find(int l, int r, int[] arr) {
        int index = l;
        for (int i = l + 1; i <= r; i++) {
            if (arr[index] < arr[i]) {
                index = i;
            }
        }
        return index;
    }

    static long start(int[] a, int k) {
        if (a.length == 0)
            return 0;
        if (a.length <= k)
            return 2 * a[a.length - 1];
        long ans = 0;
        int i = 0;
        for (i = k - 1; i < a.length; i += k) {
            ans += 2 * a[i];
        }
        i -= k;
        if (i != a.length - 1) {
            return ans + 2 * a[a.length - 1];
        } else
            return ans;
    }

    static long end(int[] a, int k) {
        if (a.length == 0)
            return 0;
        if (a.length <= k)
            return a[a.length - 1];
        if (k == 1) {
            long sum = 0;
            for (int i = 0; i < a.length - 1; i++)
                sum += 2 * a[i];
            return sum + a[a.length - 1];
        }
        long ans = 0;
        int i = 0;
        for (i = k - 1; i < a.length; i += k) {
            if (i != a.length - 1)
                ans += 2 * a[i];
        }
        i -= k;
        return ans + a[a.length - 1];
    }

    static void print(int[] a) {
        for (int i = 0; i < a.length; i++)
            p(a[i] + " ");
        pn("");
    }

    static long count(long n) {
        long count = 0;
        while (n != 0) {
            n /= 10;
            count++;
        }
        return count;
    }

    static void swap(long a, long b) {
        long temp = a;
        a = b;
        b = temp;
    }

    static void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    static int LcsOfPrefix(String a, String b) {
        int i = 0;
        int j = 0;
        int count = 0;
        while (i < a.length() && j < b.length()) {
            if (a.charAt(i) == b.charAt(j)) {
                j++;
                count++;
            }
            i++;
        }
        return a.length() + b.length() - 2 * count;
    }

    static void reverse(int[] a, int n) {
        for (int i = 0; i < n / 2; i++) {
            int temp = a[i];
            a[i] = a[n - i - 1];
            a[n - i - 1] = temp;
        }
    }

    static char get_char(int a) {
        return (char) (a + 'a');
    }

    static void dfs(int i, List<List<Integer>> arr, boolean[] visited, int parent) {
        visited[i] = true;
        for (int v : arr.get(i)) {
            if (!visited[v]) {
                dfs(v, arr, visited, i);
            }
        }
    }

    static int find1(List<Integer> a, int val) {
        int ans = -1;
        int l = 0;
        int r = a.size() - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (a.get(mid) >= val) {
                r = mid - 1;
                ans = mid;
            } else
                l = mid + 1;
        }
        return ans;
    }

    static int find2(List<Integer> a, int val) {
        int l = 0;
        int r = a.size() - 1;
        int ans = -1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (a.get(mid) <= val) {
                ans = mid;
                l = mid + 1;
            } else
                r = mid - 1;
        }
        return ans;
    }

    static void dfs(List<List<Integer>> arr, int node, int parent, long[] val) {
        p[node] = parent;
        in_time[node] = count;
        flat_tree[count] = val[node];
        subtree_gcd[node] = val[node];
        count++;
        for (int adj : arr.get(node)) {
            if (adj == parent)
                continue;
            dfs(arr, adj, node, val);
            subtree_gcd[node] = gcd(subtree_gcd[adj], subtree_gcd[node]);
        }
        out_time[node] = count;
        flat_tree[count] = val[node];
        count++;
    }
}