#ifndef LOCAL
#pragma GCC optimize("O3,unroll-loops")
#endif

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/rope>
// using namespace __gnu_cxx;
// using namespace __gnu_pbds;

using namespace std;

template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;

using ld = long double;
using ll = long long;
using PLL = pair<ll, ll>;
using PII = pair<int, int>;
using VI = V<int>;
using VLL = V<ll>;
using VVI = VV<int>;
using VVLL = VV<ll>;
using Gr = VVI;
using MLL = map<ll, ll>;
#define UMLL unordered_map<ll, ll, custom_hash>

#define fast                                                                                                           \
    ios_base::sync_with_stdio(0);                                                                                      \
    cin.tie(nullptr);                                                                                                  \
    cout.tie(nullptr);

#define CR const &

#define ALL(obj) begin(obj), end(obj)
#define RALL(obj) rbegin(obj), rend(obj)

#ifdef LOCAL
#define OK cerr << "OK" << endl;
#else
#define OK
#endif

template <class T> T sqr(T x) { return x * x; }

template <class T, class U = T> void cmin(T &a, U const &b) {
    if (b < a)
        a = b;
}

template <class T, class U = T> void cmax(T &a, U const &b) {
    if (a < b)
        a = b;
}

#ifdef LOCAL

void print_raw() {}

template <class T> void print_raw(T CR);

void print_raw(string CR);

template <class T, class U> void print_raw(pair<T, U> CR);

template <ranges::range T> void print_raw(T CR);

void print_raw(const char *);

template <class T> void print_raw(T CR t) { cerr << t << " "; }

void print_raw(string CR t) { cerr << t << " "; }

template <class T, class U> void print_raw(pair<T, U> CR t) {
    cerr << '{';
    print_raw(t.first);
    cerr << "\b, ";
    print_raw(t.second);
    cerr << "\b} ";
}

template <ranges::range T> void print_raw(T CR t) {
    cerr << '{';

    for (auto i : t)
        print_raw(i);
    if (!empty(t))
        cerr << '\b';

    cerr << "} ";
}

void print_raw(const char *t) {
    if (!t)
        return; //?

    auto sz = strlen(t);
    cerr << t;
    if (sz == 0 || t[sz - 1] != '\n')
        cerr << ' ';
}

template <class T, class... Ts> void print_raw(T CR t, Ts CR... vals) {
    print_raw(t);
    print_raw(vals...);
}

template <class... Ts> void print(Ts CR... vals) {
    print_raw(vals...);
    cerr << '\n';
}

#else

template <class... Ts> void print_raw(Ts CR... vals) {}

template <class... Ts> inline void print(Ts CR... vals) {}

#endif

template <class T> void show(T CR t, ostream &os = cerr) {
    for (auto CR i : t)
        os << i << " ";
    os << "\n";
}

template <class T> void show2d(T CR t, ostream &os = cerr) {
    for (auto CR i : t)
        show(i, os);
    os << "\n";
}

constexpr ll MOD = 998244353;

constexpr ll INF = 1e16;

const ld PI = atanl(1.0L) * 4;
constexpr ld eps = 1e-6, EPS = 1e-9;

// https://codeforces.com/blog/entry/62393
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

template <class T> T &addfix(T &x, ll mod = MOD) {
    if (x >= mod)
        x -= mod;
    return x;
}

template <class T> T &subfix(T &x, T mod = MOD) {
    if (x < 0)
        x += mod;
    return x;
}

template <class T> T &afix(T &x, ll mod = MOD) {
    if (x < 0)
        x += mod;
    else if (x >= mod)
        x -= mod;
    return x;
}

template <class T> T &fix(T &x, T mod = MOD) {
    x %= mod;
    subfix(x, mod);
    return x;
}

ll qpow(ll a, ll b, ll mod = MOD) {
    ll res = 1;
    while (b) {
        if (b & 1LL)
            res = res * a % mod;

        b >>= 1LL;
        a = sqr(a) % mod;
    }

    return res;
}

ll inv(ll a, ll mod = MOD) { return qpow(a, mod - 2, mod); }

ll rand(ll l, ll r) { return rand() % (r - l + 1) + l; }

void init() {}

set<PII> read_graph() {
    int m;
    cin >> m;

    set<PII> G;
    for (int i = 0; i < m; ++i) {
        int u, v;
        cin >> u >> v;

        --u;
        --v;

        G.insert({u, v});
        G.insert({v, u});
    }
    return G;
}

struct T {
    char c;
    int u, v;
};

V<T> to_star(int n, set<PII> G) {
    VVI g(n);
    for (auto [u, v] : G)
        g[u].push_back(v);

    V<T> res;
    auto add_edge = [&](int u, int v) {
        if (u == v || G.count({u, v}))
            return;

        res.emplace_back('+', u, v);
        G.insert({u, v});
        G.insert({v, u});
    };

    auto rem_edge = [&](int u, int v) {
        if (u == v || !G.count({u, v}))
            return;

        res.emplace_back('-', u, v);
        G.erase({u, v});
        G.erase({v, u});
    };

    VI was(n);
    queue<int> q;

    auto push = [&](int u) {
        if (was[u])
            return;

        was[u] = 1;
        q.push(u);
    };

    push(0);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        add_edge(0, u);

        for (auto v : g[u])
            push(v);
    }

    auto cpy = G;
    for (auto [u, v] : cpy)
        if (u != 0 && v != 0)
            rem_edge(u, v);
    return res;
}

void solve(int test_id) {
    int n;
    cin >> n;

    set<PII> G1 = read_graph(), G2 = read_graph();
    auto ans = to_star(n, G1);

    auto rev = to_star(n, G2);
    reverse(ALL(rev));
    for (auto &[c, u, v] : rev)
        c = c == '+' ? '-' : '+';

    ans.insert(end(ans), ALL(rev));
    cout << ans.size() << "\n";
    for (auto [c, u, v] : ans)
        cout << c << " " << u + 1 << " " << v + 1 << "\n";
}

int main() {
    auto seed = time(nullptr);
    // cerr << "seed: " << seed << "\n";
    srand(seed);
    fast;
    init();
    int q = 1;
    // cin >> q;

    cout << setprecision(999);
    for (int id = 1; id <= q; ++id)
        solve(id);
}