//Krzysztof Pieprzak
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int,int> pii;
typedef pair<long long, long long> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;

#define Size(x) (int)x.size()
#define VAR(v,n) auto v = (n)
#define FOR(i,a,b) for(VAR(i,a); i < (b); ++i)
#define FORE(i,a,b) for(VAR(i,a); i <= (b); ++i)
#define FORREV(i,a,b) for(VAR(i,b); i >= (a); --i)
#define FORSTEP(i,a,b,step) for(VAR(i,a); i < (b); i += (step))
#define FOREACH(i,c) for(auto i : (c))
#define FOREACHS(i,c,n) for(VAR(i,&(c)[0]); i-(c)<(n); ++i)
#define ALL(x) x.begin(),x.end()
#define CLEAR(t) memset(t, 0, sizeof(t))
#define F first
#define S second
#define MP make_pair
#define PUB push_back
#define POB pop_back
#define pieprzu ios_base::sync_with_stdio(0);
#define debug if(0)

const int    INF = 1000000001;
const double EPS = 10e-9;

const int MAXN = 30000;

struct Operation {
    char sign;
    int v1;
    int v2;

    Operation(char sign, int v1, int v2) : sign(sign), v1(v1), v2(v2) {}
};

vi tInit[MAXN + 5];
vi tFinal[MAXN + 5];

bool visited[MAXN + 5];

int n, mInit, mFinal;
int vSpecial = 1;

vi postOrderOnFinalGraph;
bool shouldBeConnectedToVSpecialInFinal[MAXN + 5];

vector<Operation> operations;

void addOperationAddEdge(int v1, int v2) {
    operations.PUB(Operation('+', v1, v2));
}

void addEdge(int v1, int v2) {
    tInit[v1].PUB(v2);
    tInit[v2].PUB(v1);
    addOperationAddEdge(v1, v2);
}

void addOperationRemoveEdge(int v1, int v2) {
    operations.PUB(Operation('-', v1, v2));
}

void printEdges(int v, vi* graph) {
    printf("%d: ", v);
    FOREACH (w, graph[v]) {
        printf("%d ", w);
    }
    printf("\n");
}

void connectAllToVSpecial() {
    sort(ALL(tInit[vSpecial]));

    debug printf("vSpecial start\n");
    debug printEdges(vSpecial, tInit);

    int iInit = 0;
    FORE (v, 1, n) {
        if (v != vSpecial) {
            if (tInit[vSpecial][iInit] != v) {
                debug printf("Adding edge <%d, %d>\n", vSpecial, v);
                addEdge(vSpecial, v);
            } else {
                ++iInit;
            }
        }
    }

    debug printf("vSpecial all\n");
    debug printEdges(vSpecial, tInit);
}

void addAndRemoveEdgesIgnoringVSpecial() {
    FORE (v, 1, n) {
        if (v != vSpecial) {
            sort(ALL(tInit[v]));
            sort(ALL(tFinal[v]));

            debug printf("\n");
            debug printEdges(v, tInit);
            debug printEdges(v, tFinal);

            int nInit = Size(tInit[v]);
            int nFinal = Size(tFinal[v]);
            int jInit = 0;
            int jFinal = 0;
            debug printf("Parameters for next iteration: <%d, %d, %d, %d, %d>\n", v, jInit, nInit, jFinal, nFinal);
            while ((jInit < nInit && tInit[v][jInit] < v) || (jFinal < nFinal && tFinal[v][jFinal] < v)) {
                // edge exists in both init and final graph
                if (jInit < nInit && jFinal < nFinal && tInit[v][jInit] == tFinal[v][jFinal]) {
                    debug printf("Edge <%d, %d> exists in both graphs - skipping\n", v, tInit[v][jInit]);
                    ++jInit;
                    ++jFinal;
                // edge exists only in the init graph - remove edge if it's not connected to specialV
                } else if (jInit < nInit && (jFinal >= nFinal || tInit[v][jInit] < tFinal[v][jFinal])) {
                    debug printf("Edge <%d, %d> exists only in the init graph ", v, tInit[v][jInit]);
                    if (tInit[v][jInit] != vSpecial) {
                        debug printf("- removing\n");
                        addOperationRemoveEdge(v, tInit[v][jInit]);
                    } else {
                        debug printf("but it is connected to vSpecial - skipping\n");
                    }
                    ++jInit;
                // edge exists only in the final graph - add edge
                } else { // jInit == nInit || (jFinal < nFinal && tInit[v][jInit] > tFinal[v][jFinal])
                    debug printf("Edge <%d, %d> exists only in the final graph - adding\n", v, tFinal[v][jFinal]);
                    addOperationAddEdge(v, tFinal[v][jFinal]);
                    ++jFinal;
                }
                debug printf("Parameters for next iteration: <%d, %d, %d, %d, %d>\n", v, jInit, nInit, jFinal, nFinal);
            }
        }
    }
}

void dfsOnFinalGraph(int v) {
    visited[v] = 1;

    FOREACH (w, tFinal[v]) {
        if (!visited[w]) {
            dfsOnFinalGraph(w);
        }
    }

    postOrderOnFinalGraph.PUB(v);
}

void removeRedundantEdgesFromVSpecial() {
    if (Size(tFinal[vSpecial]) == n - 1) {
        debug printf("\nNo need to remove anything connected to vSpecial\n");
        return;
    }

    FOREACH (v, tFinal[vSpecial]) {
        shouldBeConnectedToVSpecialInFinal[v] = 1;
    }

    dfsOnFinalGraph(vSpecial);
    debug {
        printf("\npostOrderOnFinalGraph\n");
        FOREACH (v, postOrderOnFinalGraph) {
            printf("%d ", v);
        }
        printf("\n");
    }

    FOREACH (v, postOrderOnFinalGraph) {
        if (v != vSpecial && !shouldBeConnectedToVSpecialInFinal[v]) {
            debug printf("Removing edge <%d, %d>\n", vSpecial, v);
            addOperationRemoveEdge(vSpecial, v);
        }
    }
}

void rob(int test) {
    scanf("%d", &n);

    int a, b;
    scanf("%d", &mInit);
    FOR (i, 0, mInit) {
        scanf("%d %d", &a, &b);
        tInit[a].PUB(b);
        tInit[b].PUB(a);
    }

    scanf("%d", &mFinal);
    FOR (i, 0, mFinal) {
        scanf("%d %d", &a, &b);
        tFinal[a].PUB(b);
        tFinal[b].PUB(a);
    }

    // at most n operations
    connectAllToVSpecial();

    // at most mFinal added edges and mInit removed edges = at most mInit + mFinal operations
    addAndRemoveEdgesIgnoringVSpecial();

    // at most n operations
    removeRedundantEdgesFromVSpecial();

    // total operations <= n + mInit + mFinal + n = 2 * 30000 + 2 * 50000 = 160000 < 200000
    printf("%d\n", Size(operations));
    FOREACH (operation, operations) {
        printf("%c %d %d\n", operation.sign, operation.v1, operation.v2);
    }
}

int main() {
    int test = 1;
    //scanf("%d", &test);

    FORE (i, 1, test) rob(i);

    return 0;
}