Problem: This problem is interactive.

We have hidden a permutation p_1, p_2, ..., p_n of numbers from 1 to n from you, where n is even. You can try to guess it using the following queries:

? k a_1 a_2 ... a_k.

In response, you will learn if the average of elements with indexes a_1, a_2, ..., a_k is an integer. In other words, you will receive 1 if \frac{p_{a_1} + p_{a_2} + ... + p_{a_k}}{k} is integer, and 0 otherwise. 

You have to guess the permutation. You can ask not more than 18n queries.

Note that permutations [p_1, p_2, ..., p_k] and [n + 1 - p_1, n + 1 - p_2, ..., n + 1 - p_k] are indistinguishable. Therefore, you are guaranteed that p_1 ≤ n/2.

Note that the permutation p is fixed before the start of the interaction and doesn't depend on your queries. In other words, interactor is not adaptive.

Note that you don't have to minimize the number of queries.

Input

The first line contains a single integer n (2 ≤ n ≤ 800, n is even).

Interaction

You begin the interaction by reading n.

To ask a question about elements on positions a_1, a_2, ..., a_k, in a separate line output

? k a_1 a_2 ... a_k

Numbers in the query have to satisfy 1 ≤ a_i ≤ n, and all a_i have to be different. Don't forget to 'flush', to get the answer.

In response, you will receive 1 if \frac{p_{a_1} + p_{a_2} + ... + p_{a_k}}{k} is integer, and 0 otherwise. 

In case your query is invalid or you asked more than 18n queries, the program will print -1 and will finish interaction. You will receive a Wrong answer verdict. Make sure to exit immediately to avoid getting other verdicts.

When you determine permutation, output 

! p_1 p_2 ... p_n

After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:

  * fflush(stdout) or cout.flush() in C++;
  * System.out.flush() in Java;
  * flush(output) in Pascal;
  * stdout.flush() in Python;
  * see documentation for other languages.



Hack format

For the hacks use the following format:

The first line has to contain a single integer n (2 ≤ n ≤ 800, n is even).

In the next line output n integers p_1, p_2, ..., p_n — the valid permutation of numbers from 1 to n. p_1 ≤ n/2 must hold.

Example

Input


2
1 2


Output


? 1 2
? 1 1
! 1 2 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
  if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
  if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
  return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
  os << "{";
  for (auto e : v) os << e << ",";
  return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
  return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
  if (i) os << ",";
  os << get<i>(t);
  print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
  os << "{";
  print_tuple<0, tuple<Args...>, Args...>(os, t);
  return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
  cout << x;
  if (suc == 1) cout << "\n";
  if (suc == 2) cout << " ";
}
ll read() {
  ll i;
  cin >> i;
  return i;
}
vi readvi(ll n, ll off = 0) {
  vi v(n);
  for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
  return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
  for (ll i = ll(0); i < ll(v.size()); i++)
    print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
  string s;
  cin >> s;
  return s;
}
template <class T>
T sq(const T& t) {
  return t * t;
}
void yes(bool ex = true) {
  cout << "Yes"
       << "\n";
  if (ex) exit(0);
}
void no(bool ex = true) {
  cout << "No"
       << "\n";
  if (ex) exit(0);
}
void possible(bool ex = true) {
  cout << "Possible"
       << "\n";
  if (ex) exit(0);
}
void impossible(bool ex = true) {
  cout << "Impossible"
       << "\n";
  if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
bool inc(ll first, ll second, ll c) { return first <= second && second <= c; }
template <class t>
void mkuni(vc<t>& v) {
  sort(v.begin(), v.end());
  v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
  static mt19937_64 gen;
  return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
  return lower_bound(v.begin(), v.end(), first) - v.begin();
}
ll gcd(ll first, ll second) {
  return second ? gcd(second, first % second) : first;
}
ll lcm(ll first, ll second) { return first / gcd(first, second) * second; }
ll extgcd(ll first, ll second, ll& x, ll& y) {
  if (second == 0) {
    x = 1;
    y = 0;
    return first;
  } else {
    ll g = extgcd(second, first % second, y, x);
    y -= first / second * x;
    return g;
  }
}
pi modinv(ll x, ll m) {
  ll first, second;
  ll g = extgcd(x, m, first, second);
  if (first < 0) first += m / g;
  return pi(g, first);
}
pi crt(ll first, ll second, ll c, ll d) {
  if (second < d) {
    swap(first, c);
    swap(second, d);
  }
  c %= d;
  ll g, e;
  tie(g, e) = modinv(second, d);
  ll k = (c - first);
  if (k % g) return pi(-1, -1);
  k /= g;
  ll m = second / g * d;
  ll x = (first + k * e % (d / g) * second) % m;
  if (x < 0) x += m;
  return pi(x, m);
}
bool dbg = false;
vi ysp;
ll qcnt;
vi kmzk;
bool ask(vi first) {
  assert(ll(first.size()));
  if (ll(first.size()) == 1) return true;
  qcnt++;
  for (auto& v : first) v = kmzk[v];
  if (dbg) {
    ll s = 0;
    for (auto i : first) s += ysp[i];
    return s % ll(first.size()) == 0;
  } else {
    cout << "? " << ll(first.size());
    for (auto v : first) cout << " " << v + 1;
    cout << endl;
    return read();
  }
}
void shf(vi& first) {
  for (ll i = ll(0); i < ll(ll(first.size())); i++)
    swap(first[i], first[rand_int(0, i)]);
}
pi getmnmx(vi x) {
  assert(ll(x.size()) % 2 == 0);
  if (ll(x.size()) == 2) return {x[0], x[1]};
  ll n = ll(x.size());
  shf(x);
  ll first = -1, second = -1;
  for (ll i = ll(0); i < ll(n); i++) {
    vi y = x;
    y.erase(y.begin() + i);
    if (ask(y)) {
      if (first == -1)
        first = x[i];
      else {
        second = x[i];
        break;
      }
    }
  }
  return pi(first, second);
}
void answer(vi first) {
  void(0);
  ll n = ll(first.size());
  for (ll i = ll(0); i < ll(n); i++) assert(inc(1, first[i], n));
  {
    vi second(n);
    for (ll i = ll(0); i < ll(n); i++) second[kmzk[i]] = first[i];
    first = second;
  }
  if (first[0] > n / 2) {
    for (auto& v : first) v = n + 1 - v;
  }
  cout << "!";
  for (auto v : first) cout << " " << v;
  cout << endl;
  void(0);
  if (dbg) assert(first == ysp);
  cerr << qcnt << "/" << n * 18 << endl;
}
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout << fixed << setprecision(20);
  ll n;
  cin >> n;
  if (n < 0) {
    dbg = true;
    n = -n;
    ysp.resize(n);
    iota(ysp.begin(), ysp.end(), 1);
    shf(ysp);
    if (ysp[0] > n / 2) {
      for (auto& v : ysp) v = n + 1 - v;
    }
  }
  kmzk.resize(n);
  iota(kmzk.begin(), kmzk.end(), 0);
  shf(kmzk);
  ll h = min(n / 2, ll(8));
  vi dec(n);
  for (ll lv = ll(0); lv < ll(h); lv++) {
    vi idx;
    for (ll i = ll(0); i < ll(n); i++)
      if (!dec[i]) idx.push_back(i);
    ll first, second;
    tie(first, second) = getmnmx(idx);
    if (lv != 0) {
      for (ll i = ll(0); i < ll(n); i++)
        if (dec[i] == 1) {
          if (ask({i, second})) swap(first, second);
        }
    }
    ll c = lv + 1, d = n - lv;
    if (c % 2 == 0) swap(c, d);
    dec[first] = c;
    dec[second] = d;
  }
  void(0);
  vi pos(n + 1, -1);
  if (8 < n) {
    void(0);
    for (ll i = ll(0); i < ll(n); i++)
      if (dec[i]) {
        pos[dec[i]] = i;
      }
    void(0);
    for (ll i = ll(0); i < ll(n); i++)
      if (!dec[i]) {
        ll first = 0, second = 1;
        for (ll v : {3, 5, 7, 8}) {
          {
            ll num = 0;
            for (ll t = ll(1); t < ll(n + 1); t++)
              if (t % second == first && pos[t] == -1) num++;
            assert(num);
            if (num == 1) break;
          }
          vi u(pos.begin() + 1, pos.begin() + v + 1);
          shf(u);
          u.push_back(i);
          for (ll j = ll(0); j < ll(v); j++) {
            vi w = u;
            w.erase(w.begin() + j);
            ll sum = 0;
            for (ll k = ll(0); k < ll(v - 1); k++) sum += dec[w[k]];
            ll m = (v - sum % v) % v;
            void(0);
            ll e, f;
            tie(e, f) = crt(first, second, m, v);
            {
              ll num = 0;
              for (ll t = ll(1); t < ll(n + 1); t++)
                if (t % f == e && pos[t] == -1) num++;
              if (num == 0) continue;
            }
            if (j == v - 1 || ask(w)) {
              tie(first, second) = pi(e, f);
              break;
            }
          }
        }
        while (first == 0 || pos[first] != -1) first += second;
        dec[i] = first;
        pos[first] = i;
      }
  }
  answer(dec);
}