This is an interactive problem

Ginny is taking an exam on game theory. The professor is tired of hearing the same answers over and over again, so he offered Ginny to play a game instead of a standard exam. 

As known from the course, a combinatorial game on a graph with multiple starting positions is a game with a directed graph and multiple starting vertices holding a token each. Two players take turns moving one of the tokens along the graph edges on each turn. The player who can't make a move loses the game. If both players can play an infinitely long game without losing, a draw is called.

For the exam, the professor drew an acyclic directed graph and chose one of its vertices. Ginny needs to guess the vertex the professor chose. To do so, Ginny can choose a multiset of vertices S several times and ask the professor: "If I put one token in each vertex of the given graph for each occurrence of the vertex in the multiset S, and then one more in the selected vertex, what would be the result of the combinatorial game?". 

Having given the task, the professor left the room to give Ginny some time to prepare for the game. Ginny thinks that she's being tricked because the problem is impossible to solve. Therefore, while the professor is away, she wants to add or remove several edges from the graph. Even though the original graph was acyclic, edges could be added to the graph to make cycles appear.

Interaction

In this task, interaction consists of several phases.

In the first phase, the interactor gives as an input to your program three integers N (1 ≤ N ≤ 1000), M (0 ≤ M ≤ 100 000), T (1 ≤ T ≤ 2000): the number of vertices and edges in the initial graph, and the number of times Ginny has to guess the chosen vertex. The next M lines contain pairs of vertices a_i b_i (1 ≤ a_i, b_i ≤ N): beginning and end of corresponding graph edges. The graph is guaranteed to be acyclic and all of its edges to be distinct.

The solution should print an integer K (0 ≤ K ≤ 4242): the number of edges to change in the graph. The next K lines should contain either "+ a_i b_i" or "- a_i b_i": the beginning and the end of an edge that Ginny has to add or remove accordingly. You are allowed to add preexisting edges to the graph. Operations are performed in the order of appearance, so Ginny is allowed to remove an edge added by the solution. You can only remove an existing edge. The operations can create cycles in the graph. 

The next T phases are dedicated to guessing the chosen vertices. In each phase, the solution can make at most 20 queries and then print the answer. To query a multiset S, the solution should print "? |S|~S_1~S_2~...~S_{|S|}". The total size of all multisets in a single phase should not exceed 20. The interactor will reply with one of the following words: 

  * "Win", if the winner of a combinatorial game with tokens in multiset S and the selected vertex is the first player. 
  * "Lose", if the winner of a combinatorial game with tokens in multiset S and the selected vertex is the second player. 
  * "Draw", if a combinatorial game with tokens in multiset S and selected vertex ends in a draw. 
  * "Slow", if the solution made a 21-st request, or the total size of all multisets in a single phase exceeded 20. In this case, the solution should terminate and receive Wrong Answer verdict. 



As soon as the selected vertex is guessed, that solution should print "! v". If the chosen vertex is guessed correctly, the interactor will print Correct and the solution should either move on to the next phase of guessing or finish its execution if it's the last phase. Otherwise, the interactor will print Wrong, which means that the solution should terminate and will receive the Wrong Answer verdict. 

The interactor can change the chosen vertex based on graph changes and solution actions, but at every given moment of time, at least one vertex that corresponds to all given interactor answers will exist. 

Hack format

Hacks have the following extra limitations: 

  * T = 1 
  * you need to specify a single vertex, chosen by the interactor. 



Hack test format. The first line of input contains three integers N~M~1. The next M lines on input contain edge description in the same format as in the input. The next line contains a single integer v: the number of the chosen vertex. The hack will be successful even if the solution guesses the vertex right, but the vertex will not be the single one to match all performed queries.

Example

Input


3 2 3
1 2
2 3

Lose

Correct

Win

Correct

Draw

Correct

Output


6
+ 2 2
- 1 2
+ 2 3
- 2 2
+ 3 1
+ 2 2
? 0

! 1

? 1 2

! 3

? 5 1 3 1 3 1

! 2

Note

In the sample test, the empty lines represent waiting for the input by the other side of the interaction. The real interactor will not print empty lines, and the solution should not print them either. 

<image>

The image above illustrates the sample test. Added edges are coloured in red, and the removed edges are drawn with a dotted line. Three guessing phases denote different ways of getting the answer. 

  * If the solution will query just the chosen vertex, the interactor will return the result of the game in that vertex. The first player loses only if the chosen vertex has the number 1. 
  * If we add a single vertex 2 to the chosen vertex, then if the chosen vertex is either 1 or 2, the game should end in a draw. If vertex number 3 is chosen, then the first player wins. 
  * If we place three tokens in vertex 1 and two tokens in vertex 3, then the game will end in a draw only if vertex 2 is chosen. If the professor chose vertex 3, the first player will win, if the professor chose vertex 1, then the second player will win. 



In the first test, the interactor will behave as if the chosen vertices are the same as those in the example above. However, if you will try to guess the answer before it limits the options to one single vertex, the solution will get "Wrong Answer", even if you print the same answers. That's because the interactor is allowed to change the chosen vertex if it's consistent with the previous query answers.
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const long long mod = 998244353;
const long long Inf = 1e18;
int inv[1 << 20], cnt, f[N], val[N], mini, id[N];
vector<int> g[N];
bool vis[N];
void dfs(int u) {
  vis[u] = 1;
  for (auto v : g[u]) {
    if (!vis[v]) dfs(v);
    val[u] += val[v] * f[v];
  }
  if (cnt < mini) {
    val[u] = 1 << cnt;
    f[u] = 1;
  }
  id[cnt] = u;
  ++cnt;
}
void add(int u, int v, int c) {
  if (c)
    printf("+ %d %d\n", u, v);
  else
    printf("- %d %d\n", u, v);
}
void check(int u, int i) {
  if (val[u] & (1 << i))
    printf("- %d %d\n", u, id[i]);
  else
    printf("+ %d %d\n", u, id[i]);
}
int main() {
  int n, m, T;
  scanf("%d%d%d", &n, &m, &T);
  while (m--) {
    int u, v;
    scanf("%d%d", &u, &v);
    g[u].push_back(v);
  }
  mini = min(n, 20);
  for (int i = (1); i < (n + 1); ++i) {
    if (!vis[i]) dfs(i);
  }
  printf("%d\n", (mini - 1) * mini / 2 + 4 * (n - mini));
  for (int i = (0); i < (n); ++i) {
    if (i < mini) {
      for (int j = (0); j < (i); ++j) add(id[i], id[j], 1);
    } else {
      add(id[i], id[i], 1);
      int u = id[i];
      int ok = 0;
      for (int j = (0); j < (mini); ++j) {
        for (int k = (j + 1); k < (mini); ++k) {
          for (int l = (k + 1); l < (mini); ++l) {
            int mask = val[u] ^ (1 << j) ^ (1 << k) ^ (1 << l);
            if (!ok && !inv[mask]) {
              ok = 1;
              inv[mask] = u;
              check(u, j);
              check(u, k);
              check(u, l);
            }
          }
        }
      }
    }
  }
  char s[10];
  while (T--) {
    int ans = 0, ok = 0;
    for (int i = (0); i < (mini); ++i) {
      printf("? 1 %d\n", id[i]);
      fflush(stdout);
      scanf("%s", s);
      if (s[0] == 'W') ans |= 1 << i;
      if (s[0] == 'L') ok = id[i];
    }
    ans = inv[ans];
    if (ok) ans = ok;
    printf("! %d\n", ans);
    fflush(stdout);
    scanf("%s", s);
  }
}
