#include <stdio.h>
#include <string.h>

typedef struct {
    int type;
    char c1, c2;
} Query;

Query queries[1000005];
char final_map[26];
char result[1000005];

int main() {
    int n;
    scanf("%d", &n);
    int room_count = 0;

    // 1. Đọc và đếm số phòng
    for (int i = 0; i < n; i++) {
        scanf("%d", &queries[i].type);
        if (queries[i].type == 1) {
            scanf(" %c", &queries[i].c1);
            room_count++;
        } else {
            scanf(" %c %c", &queries[i].c1, &queries[i].c2);
        }
    }

    // 2. Khởi tạo ánh xạ màu ban đầu (a->a, b->b, ...)
    for (int i = 0; i < 26; i++) {
        final_map[i] = 'a' + i;
    }

    // 3. Quay ngược thời gian xử lý các thao tác
    int current_room_idx = room_count;
    for (int i = n - 1; i >= 0; i--) {
        if (queries[i].type == 1) {
            // Ghi nhận màu cuối cùng của phòng vào kết quả
            // queries[i].c1 là màu được sơn tại thời điểm đó
            // final_map[...] là màu hiện tại của mã màu đó
            result[current_room_idx - 1] = final_map[queries[i].c1 - 'a'];
            current_room_idx--;
        } else {
            // Type 2: Cập nhật bảng ánh xạ
            // Nếu trước đó có màu A và đổi thành B, thì sau khi đổi B thành C, A sẽ thành C.
            // Logic: Tìm màu cuối cùng của 'from' màu, và gán nó thành màu cuối cùng của 'to' màu.
            // Lưu ý: final_map[queries[i].c1 - 'a'] = final_map[queries[i].c2 - 'a'];

            // Để tránh lỗi nếu cùng một màu (ví dụ 2 a a), ta cần xử lý cẩn thận.
            // Nhưng trong logic quay ngược, ta cần tracking nhiều màu.
            // Đơn giản nhất: Duyệt lại toàn bộ map để thay thế.
            // Tối ưu hơn: Chỉ cập nhật giá trị.

            char from = queries[i].c1;
            char to = queries[i].c2;

            // Nếu 'from' và 'to' giống nhau, không cần làm gì.
            if (from != to) {
                // Logic chuẩn: Màu X tại thời điểm hiện tại sẽ trở thành màu mà Y đang trở thành.
                // Tuy nhiên, ta cần update tất cả các màu trong final_map mà đang trỏ đến 'from' thành 'to'?
                // Không, logic đúng là:
                // Thao tác: Sơn phòng màu x thành y.
                // Trong quá khứ, phòng có màu x.
                // Sau thao tác này, nó thành y.
                // Khi quay ngược, ta biết rằng phòng màu y (tại thời điểm sau thao tác) trước đó là màu x.
                // Vậy: Nếu final_map[k] == from, thì final_map[k] = to? 
                // Không. Logic của giải pháp accepted là:
                // final_map[from - 'a'] = final_map[to - 'a'];
                // Nghĩa là: Bất kỳ màu nào trước đó là 'from', về sau sẽ là whatever 'to' trở thành.
                // 
                // Ví dụ: 2 a b. 
                // Khi quay ngược: 
                // Nếu ta thấy một phòng được sơn 'a' ở quá khứ, sau thao tác này nó thành 'b'.
                // Nhưng 'b' có thể đã đổi thành 'c' ở các thao tác sau.
                // Vậy 'a' sẽ thành 'c'.
                // Công thức: final_map['a'] = final_map['b'] (giá trị hiện tại của 'b').

                // Tuy nhiên, có một vấn đề về logic nếu dùng mảng 1 chiều.
                // Ví dụ: 2 a b, 2 b c. 
                // Map sau: a->b, b->c. 
                // Khi quay ngược từ cuối lên:
                // 2 b c: final_map['b'] = final_map['c'] = 'c'. (Giả định ban đầu map[c]=c)
                // 2 a b: final_map['a'] = final_map['b'] = 'c'.
                // Kết quả đúng.

                final_map[from - 'a'] = final_map[to - 'a'];
            }
        }
    }

    // 4. In kết quả
    for (int i = 0; i < room_count; i++) {
        printf("%c", result[i]);
    }
    printf("\n");
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;

    vector<char> final_colors(n, 0); // Dùng để lưu màu của từng phòng
    int room_count = 0;

    // parent[i] đại diện cho màu i đang trỏ đến màu nào
    // Ban đầu: parent[i] = i
    int parent[26];
    for(int i=0; i<26; ++i) parent[i] = i;

    // Duyệt từ đầu
    for(int i=0; i<n; ++i) {
        int type;
        cin >> type;
        if(type == 1) {
            char c;
            cin >> c;
            // Tìm màu cuối cùng của c ngay tại thời điểm này
            int root = c - 'a';
            while(parent[root] != root) {
                root = parent[root];
            }
            // Path compression (tùy chọn để tối ưu, nhưng không cần thiết lắm nếu chỉ query 1 lần)
            // Lưu màu vào phòng
            final_colors[room_count] = (char)('a' + root);
            room_count++;
        } else {
            char x, y;
            cin >> x >> y;
            int u = x - 'a';
            int v = y - 'a';

            if(u != v) {
                // Logic Union Find: Gộp u vào v
                // Nhưng ta cần xử lý cẩn thận:
                // Nếu ta sơn màu x thành y, thì mọi thứ đang là x sẽ thành y.
                // Trong UF, ta cần map root của u thành root của v.

                // Tuy nhiên, UF chuẩn không xử lý được việc "tất cả các node đang trỏ đến u đều trỏ đến v".
                // Ta cần một biến phụ hoặc thay đổi logic.
                // 
                // Cách tiếp cận UF "tô màu":
                // parent[u] = v; (Nếu u là root)
                // Nhưng nếu có nhiều màu trỏ đến u?
                // 
                // Thực tế, UF đơn giản ở đây không đủ mạnh.
                // Cần dùng "Disjoint Set Union on Colors" với mảng mapping.
                // Hoặc đơn giản là dùng mảng `color_map` update.
            }
        }
    }

    // In kết quả
    for(int i=0; i<room_count; ++i) {
        cout << final_colors[i];
    }
    cout << endl;

    return 0;
}

// Lưu ý: Code trên chỉ là mô phỏng ý tưởng UF.
// Thực tế, UF không phải là lựa chọn tối ưu nhất cho bài này do độ phức tạp update.
// Giải pháp Reverse Simulation (Approach 1) là tốt nhất.