#include <iostream>
#include <cmath>
#include <vector>
#include <limits.h>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <string>
#include <algorithm>
#include <iomanip>
#include <random>
#include <time.h>
#include <bitset>
#include <queue>
#include <deque>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

#define sz(x) (int)x.size()
#define all(x) (x).begin(),(x).end()

const int MAXN = 1000 * 1000 + 1;

struct node {
    int s = 0, set = -1;
    node() {}
};

unordered_map<int, set<int>> nums;
vector<node> a(4 * MAXN), b(4 * MAXN);

void push(vector<node>& tree, int v, int tl, int tr) {
    if (tr == tl || tree[v].set == -1) return;
    int tm = (int)(tl + tr) / 2;
    tree[2 * v].set = tree[v].set;
    tree[2 * v].s = (tm - tl + 1) * tree[v].set;
    tree[2 * v + 1].set = tree[v].set;
    tree[2 * v + 1].s = (tr - tm) * tree[v].set;
    tree[v].set = -1;
}

void update(vector<node>& tree, int v, int tl, int tr, int l, int r, int x) {
    push(tree, v, tl, tr);
    if (l > r) {
        return;
    }
    if (tl == l && tr == r) {
        tree[v].set = x;
        tree[v].s = (tr - tl + 1) * x;
        return;
    }
    int tm = (tl + tr) / 2;
    update(tree, 2 * v, tl, tm, l, min(tm, r), x);
    update(tree, 2 * v + 1, tm + 1, tr, max(tm + 1, l), r, x);
    tree[v].s = tree[2 * v].s + tree[2 * v + 1].s;
}

int get_sum(vector<node>& tree, int v, int tl, int tr, int l, int r) {
    push(tree, v, tl, tr);
    if (l > r) {
        return 0;
    }
    if (tl == l && tr == r) {
        return tree[v].s;
    }
    int tm = (tl + tr) / 2;
    return get_sum(tree, 2 * v, tl, tm, l, min(tm, r)) +
        get_sum(tree, 2 * v + 1, tm + 1, tr, max(tm + 1, l), r);
}

void set_num(vector<node>& tree, int v, int tl, int tr, int pos, int val) {
    if (tl == tr) {
        tree[v].s = val;
        return;
    }
    int tm = (tl + tr) / 2;
    if (pos <= tm) {
        set_num(tree, 2 * v, tl, tm, pos, val);
    }
    else {
        set_num(tree, 2 * v + 1, tm + 1, tr, pos, val);
    }
    tree[v].s = tree[2 * v].s + tree[2 * v + 1].s;
}

int main() {

    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    int n, m;

    cin >> n;
    vector<int> aa(n);

    for (int i = 0; i < n; ++i) {
        cin >> aa[i];
    }

    cin >> m;
    vector<int> bb(m);

    for (int i = 0; i < m; ++i) {
        cin >> bb[i];
    }

    vector<int> c;

    merge(all(aa), all(bb), back_inserter(c));

    for (int i = 0; i < sz(c); ++i) {
        nums[c[i]].insert(i);
    }

    for (int i = 0; i < n; ++i) {
        int p = *(nums[aa[i]].begin());
        nums[aa[i]].erase(p);
        set_num(a, 1, 0, n + m - 1, p, 1);
    }

    for (int i = 0; i < m; ++i) {
        int p = *(nums[bb[i]].begin());
        nums[bb[i]].erase(p);
        set_num(b, 1, 0, n + m - 1, p, 1);
    }

    int q;
    cin >> q;

    for (int _ = 0; _ < q; ++_) {
        int type, l, r;
        cin >> type >> l >> r;
        if (type == 1) {
            int left = -1, right = n + m;
            while (right - left > 1) {
                int mid = (right + left) / 2;
                if (get_sum(a, 1, 0, n + m - 1, 0, mid) < l) {
                    left = mid;
                }
                else {
                    right = mid;
                }
            }
            int left_ans = right;
            int left1 = -1, right1 = n + m;
            while (right1 - left1 > 1) {
                int mid = (right1 + left1) / 2;
                if (get_sum(a, 1, 0, n + m - 1, 0, mid) < r) {
                    left1 = mid;
                }
                else {
                    right1 = mid;
                }
            }
            int right_ans = right1;
            update(a, 1, 0, n + m - 1, left_ans, right_ans, 0);
            update(b, 1, 0, n + m - 1, left_ans, right_ans, 1);
        }
        else {
            int left = -1, right = n + m;
            while (right - left > 1) {
                int mid = (right + left) / 2;
                if (get_sum(b, 1, 0, n + m - 1, 0, mid) < l) {
                    left = mid;
                }
                else {
                    right = mid;
                }
            }
            int left_ans = right;
            int left1 = -1, right1 = n + m;
            while (right1 - left1 > 1) {
                int mid = (right1 + left1) / 2;
                if (get_sum(b, 1, 0, n + m - 1, 0, mid) < r) {
                    left1 = mid;
                }
                else {
                    right1 = mid;
                }
            }
            int right_ans = right1;
            update(b, 1, 0, n + m - 1, left_ans, right_ans, 0);
            update(a, 1, 0, n + m - 1, left_ans, right_ans, 1);
        }
    }

    vector<int> ans_a, ans_b;

    for (int i = 0; i < n + m; ++i) {
        if (get_sum(a, 1, 0, n + m - 1, i, i)) {
            ans_a.push_back(c[i]);
        }
    }

    for (int i = 0; i < n + m; ++i) {
        if (get_sum(b, 1, 0, n + m - 1, i, i)) {
            ans_b.push_back(c[i]);
        }
    }

    cout << sz(ans_a) << "\n";

    for (int i : ans_a) cout << i << " ";

    cout << "\n";

    cout << sz(ans_b) << "\n";

    for (int i : ans_b) cout << i << " ";

    return 0;
}