#include <iostream>
#include <map>
#include <unordered_map>
#include <vector>
#include <unordered_set>
#include <set>
#include <queue>
#include <utility>
#include <algorithm>
#include <cassert>
#include <iomanip>
#include <tuple>
#include <stack>
#include <deque>

using namespace std;

///// TEMPLATES
typedef long long ll;
typedef tuple<ll, ll> ti2;
typedef tuple<ll, ll, ll> ti3;
typedef tuple<ll, ll, ll, ll> ti4;

typedef vector<bool>   vb;
typedef vector<vb>     vvb;
typedef vector<string> vs;

typedef vector<ll>  vi;
typedef vector<ti2> vi2;
typedef vector<ti3> vi3;
typedef vector<vi>  vvi;

typedef set<ll>  si;
typedef set<ti2> si2;
typedef set<ti3> si3;

typedef multiset<ll>  msi;
typedef multiset<ti2> msi2;
typedef multiset<ti3> msi3;

typedef deque<ll>  dqi;
typedef deque<ti2> dqi2;
typedef deque<ti3> dqi3;

template<typename T> using PQS = priority_queue<T, vector<T>, greater<T> >;
template<typename T> using PQG = priority_queue<T>;

///// OUT OPERATORS
ostream& operator<<(ostream& os, const ti2& x)  { os << "{ "; auto [a, b] = x;       os << a << ", " << b;                            os << " }"; return os; }
ostream& operator<<(ostream& os, const ti3& x)  { os << "{ "; auto [a, b, c] = x;    os << a << ", " << b << ", " << c;               os << " }"; return os; }
ostream& operator<<(ostream& os, const ti4& x)  { os << "{ "; auto [a, b, c, d] = x; os << a << ", " << b << ", " << c << ", " << d;  os << " }"; return os; }

ostream& operator<<(ostream& os, const vi& x)   { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const vs& x)   { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const vb& x)   { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const vvb& x)  { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const vi2& x)  { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const vi3& x)  { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const vvi& x)  { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }

ostream& operator<<(ostream& os, const msi& x)  { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const msi2& x) { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const msi3& x) { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }

ostream& operator<<(ostream& os, const dqi& x)  { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const dqi2& x) { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }
ostream& operator<<(ostream& os, const dqi3& x) { os << "{ "; for (auto e : x) os << e << " "; os << "}"; return os; }

///// IN OPERATORS
istream& operator>>(istream& is, ti2& x) { ll a, b;       is >> a >> b;           x = {a, b}; return is; }
istream& operator>>(istream& is, ti3& x) { ll a, b, c;    is >> a >> b >> c;      x = {a, b, c}; return is; }
istream& operator>>(istream& is, ti4& x) { ll a, b, c, d; is >> a >> b >> c >> d; x = {a, b, c, d}; return is; }


int log_floor(long long x) { return 64 - __builtin_clzll(max(1LL, x)); } // PLUS ONE!
int bit_cnt(ll x) { return __builtin_popcountll(x); }

void rev(auto& v) { reverse(v.begin(), v.end()); }
void sor(auto& v) { sort(v.begin(), v.end()); }

// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣆⠀⢀⣀⣀⣤⣤⣤⣦⣦⣤⣤⣄⣀⣀⠀⢠⣾⣿⣿⣿⣿⣿⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠛⠿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⢿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⡟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⢿⣿⠟⠀⠀⠀⠀⠀⣀⣤⣤⣤⡀⠀⠀⠀⠀⠀⢀⣤⣤⣤⣄⡀⠀⠀⠀⠀⠘⣿⡿⠿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡟⠀⠀⠀⠀⣠⣾⣿⣿⣟⣿⡇⠀⠀⠀⠀⠀⢸⣿⣿⣻⣿⣿⣦⠀⠀⠀⠀⠸⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠁⠀⠀⠀⠀⣿⣿⣿⣿⣿⡟⢠⣶⣾⣿⣿⣷⣤⢽⣿⣿⣿⣿⣿⡇⠀⠀⣀⣤⣿⣷⣴⣶⣦⣀⡀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣤⣤⣠⣇⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⠀⠘⠻⣿⣿⣿⡿⠋⠀⢹⣿⣿⣿⣿⡇⠀⣿⣿⣿⡏⢹⣿⠉⣿⣿⣿⣷⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⢠⣾⣿⣿⣿⣿⣿⣿⣿⣶⣄⠀⠀⠹⣿⣿⠿⠋⠀⢤⣀⢀⣼⡄⠀⣠⠀⠈⠻⣿⣿⠟⠀⢸⣿⣇⣽⣿⠿⠿⠿⣿⣅⣽⣿⡇⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠁⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣿⣟⠁⠀⠀⠀⠈⣿⣿⣿⡇⠀⠀⠀⠀⢀
// ⠛⠛⠛⠛⠛⠛⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛
// ⠀⠀⠀⠀⠀⠀⠘⠛⠻⢿⣿⣿⣿⣿⣿⠟⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠈⠉⠀⠀⠀⠀                          [ STASZEK ]                   
//

// graphs/structures/regular

struct Graph{
    ll n, m;
    vvi G;
    bool directed;

    void add_edge(ll x, ll y) {
        G[x].emplace_back(y);
        if (!directed) 
            G[y].emplace_back(x);
    }

    Graph(bool directed, int nn) {
        this->directed = directed;
        cin >> m;
        n = nn;
        G.resize(n + 1);
        for (ll i = 0; i < m; i ++) {
            ll x, y;
            cin >> x >> y;
            add_edge(x, y);
        }
    }

    vi2 get_edges(bool double_edges = false) {
        vi2 res;
        for (int i = 1; i <= n; i ++)
            for (auto e : G[i])
                if (i <= e || double_edges)
                    res.emplace_back(i, e);
        return res;
    }

    // Graph revGraph() {
    //     Graph G(directed, n);
    //     G.n = n;
    //     G.m = m;
    //     G.G.resize(n + 1);
    //     for (auto [x, y] : get_edges(true)) {
    //         G.add_edge(y, x);
    //     }
    //     return G;
    // }

    const vi& operator[](int node) {
        return G[node];
    }
    
    void debug() {
        cout << "-------------------\n";
        cout << "Graph " << n << " nodes & " << m << " edges\n";
        for (ll i = 1; i <= n; i ++) {
            cout << i << ": { ";
            
            for (auto x : G[i]) {
                cout << x << " ";
            }
            cout << " }\n";
        }
        cout << "-------------------\n";
    }
};


// graphs/algos/dfs

struct DFSorder{
    Graph &G;
    vb visited;
    vi order;

    void dfs(int node) {
        if (node != 1)
            order.emplace_back(node);
        visited[node] = true;
        for (int e : G[node]) {
            if (!visited[e]) {
                dfs(e);
            } 
        }
    }

    DFSorder(Graph &G, int node) : G(G) {
        visited.assign(G.n + 1, 0);
        dfs(node);
    }
};


// graphs/algos/dfs

string action(int from, int to, char c) {
    string s;
    s += c;
    s += " ";
    s += to_string(from);
    s += " ";
    s += to_string(to);
    return s;
}

string action(ti2 t, char c) {
    auto [x, y] = t;
    return action(x, y, c);
}

ti2 edge(int x, int y) {
    return ti2{min(x, y), max(x, y)};
}

struct Connect{
    si2 edges, edges_want;
    vi order1, order2;
    vs actions;

    void add_1() {
        for (auto e : order1) {
            if (edges.count(edge(1, e)))
                continue;
            edges.insert(edge(1, e));
            actions.emplace_back(action(1, e, '+'));
        }
    }

    void add_2() {
        for (auto e : edges_want) {
            if (edges.count(e))
                continue;
            edges.insert(e);
            actions.emplace_back(action(e, '+'));
        }
    }

    void remove_1() {
        for (auto [from, to] : edges) {
            if (from == 1) continue;
            if (edges_want.count(ti2{from, to})) continue;
            edges.erase(edge(from, to));
            actions.emplace_back(action(from, to, '-'));
        }
    }

    void remove_2() {
        for (auto e : order2) {
            if (!edges.count(edge(1, e))) continue;
            if (edges_want.count(edge(1, e))) continue;
            edges.erase(edge(1, e));
            actions.emplace_back(action(edge(1, e), '-'));
        }
    }

    Connect(Graph &G1, Graph& G2) {
        for (int i = 1; i <= G1.n; i ++) {
            for (auto e : G1[i]) {
                if (i < e) {
                    edges.insert(edge(i, e));
                }
            }
        }

        for (int i = 1; i <= G2.n; i ++) {
            for (auto e : G2[i]) {
                if (i < e) {
                    edges_want.insert(edge(i, e));
                }
            }
        }

        order1 = DFSorder(G1, 1).order;
        order2 = DFSorder(G2, 1).order;
        rev(order2);

        add_1();
        add_2();
        remove_1();
        remove_2();
    }
};

// inject here

void solve(){
    ll n; cin >> n;
    Graph G1(false, n);
    Graph G2(false, n);

    Connect C(G1, G2);
    cout << C.actions.size() << "\n";
    for (auto e : C.actions) {
        cout << e << "\n";
    }
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(nullptr);
    cout << setprecision(15) << fixed;
    int t = 1;
   // cin >> t;
    while (t --) solve();
    return 0;
}