#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int N;
vector<int> A, B;

int ask(const vector<int> &us) {
  printf("? %d", (int)us.size());
  for (const int u : us) {
    printf(" %d", u + 1);
  }
  puts("");
  fflush(stdout);
  char str[10];
  scanf("%s", str);
  return !strcmp(str, "YES");
}

vector<vector<int>> graph;
vector<vector<int>> uss;
void dfs(int j, int u, int p) {
  uss[j].push_back(u);
  for (const int v : graph[u]) if (p != v) {
    dfs(j, v, u);
  }
}

int main() {
  scanf("%d", &N);
  A.resize(N - 1);
  B.resize(N - 1);
  for (int i = 0; i < N - 1; ++i) {
    scanf("%d%d", &A[i], &B[i]);
    --A[i];
    --B[i];
  }
  
  graph.assign(N, {});
  for (int i = 0; i < N - 1; ++i) {
    graph[A[i]].push_back(B[i]);
    graph[B[i]].push_back(A[i]);
  }
  int r = -1;
  for (int u = 0; u < N; ++u) if (graph[u].size() >= 3) {
    r = u;
    break;
  }
  assert(~r);
  const int len = graph[r].size();
  uss.assign(len + 1, {});
  uss[len].push_back(r);
  for (int j = 0; j < len; ++j) {
    dfs(j, graph[r][j], r);
  }
  
  auto vss = uss;
  vector<int> ls;
#define uss do_not_use_uss
  for (int n = N; n > 2; ) {
    const int half = (n + 1) / 2;
    int lot = half;
    vector<vector<int>> wss(len + 1);
    for (int phase = 0; phase < 2; ++phase) {
      for (int j = 0; j < len; ++j) {
        int t = min((int)vss[j].size(), lot);
        if (phase == 0) chmin(t, 1);
        for (; t--; ) {
          wss[j].push_back(vss[j].back());
          vss[j].pop_back();
          --lot;
        }
      }
    }
    auto ws = ls;
    for (int j = 0; j < len; ++j) {
      reverse(wss[j].begin(), wss[j].end());
      ws.insert(ws.end(), wss[j].begin(), wss[j].end());
    }
    if (ask(ws)) {
      vss.swap(wss);
      n = half;
    } else {
      ls.insert(ls.end(), ws.begin(), ws.end());
      n -= half;
    }
cerr<<"vss = "<<vss<<", ls = "<<ls<<endl;
  }
#undef uss
  
  vector<int> cands;
  for (int j = 0; j <= len; ++j) {
    cands.insert(cands.end(), vss[j].rbegin(), vss[j].rend());
  }
  int ans = -1;
  if (cands.size() == 1) {
    ans = cands[0];
  } else if (cands.size() == 2) {
    for (int j = 0; j < len; ++j) if (!vss[j].size()) {
      ans = ask({uss[j].back(), cands[0]}) ? cands[0] : cands[1];
      break;
    }
  } else {
    assert(false);
  }
  printf("! %d\n", ans + 1);
  fflush(stdout);
  return 0;
}