Problem: This problem is interactive.

We have hidden an array a of n pairwise different numbers (this means that no two numbers are equal). You can get some information about this array using a new device you just ordered on Amazon. 

This device can answer queries of the following form: in response to the positions of k different elements of the array, it will return the position and value of the m-th among them in the ascending order.

Unfortunately, the instruction for the device was lost during delivery. However, you remember k, but don't remember m. Your task is to find m using queries to this device. 

You can ask not more than n queries.

Note that the array a and number m are fixed before the start of the interaction and don't depend on your queries. In other words, interactor is not adaptive.

Note that you don't have to minimize the number of queries, and you don't need to guess array a. You just have to guess m.

Input

The first line contains two integers n and k (1≤ k < n ≤ 500) — the length of the array and the number of the elements in the query.

It is guaranteed that number m satisfies 1≤ m ≤ k, elements a_1, a_2, ..., a_n of the array satisfy 0≤ a_i ≤ 10^9, and all of them are different.

Interaction

You begin the interaction by reading n and k.

To ask a question about elements on positions x_1, x_2, ..., x_k, in a separate line output

? x_1 x_2 x_3 ... x_k

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

In response, you will receive two integers pos and a_{pos} — the position in the array a of the m-th in ascending order element among a_{x_1}, a_{x_2}, ..., a_{x_k}, and the element on this position.

In case your query is invalid or you asked more than n 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 m, output 

! m

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 three integers n, k, m (1 ≤ m ≤ k < n ≤ 500) — the length of the array, number of elements in the query, and which in the ascending order number the device returns.

In the next line output n integers a_1, a_2, ..., a_n (0≤ a_i ≤ 10^9) — the elements of the array. They have to be pairwise different.

Example

Input


4 3
4 9
4 9
4 9
1 2

Output


? 2 3 4
? 1 3 4
? 1 2 4
? 1 2 3
! 3

Note

In the example, n = 4, k = 3, m = 3, a = [2, 0, 1, 9].

Solution (in JAVA):

Solution:
import java.io.*;
import java.math.BigInteger;
import java.util.*;

// written by luchy0120

public class Main {
    public static void main(String[] args) throws Exception {

        new Main().run();
    }

    static int groups = 0;
    static int[] fa;
    static int[] sz;

    static void init(int n) {
        groups = n;
        fa = new int[n];
        for (int i = 1; i < n; ++i) {
            fa[i] = i;
        }
        sz = new int[n];
        Arrays.fill(sz, 1);
    }

    static int root(int p) {
        while (p != fa[p]) {
            fa[p] = fa[fa[p]];
            p = fa[p];
        }
        return p;
    }

    static void combine(int p, int q) {
        int i = root(p);
        int j = root(q);
        if (i == j) {
            return;
        }
        if (sz[i] < sz[j]) {
            fa[i] = j;
            sz[j] += sz[i];
        } else {
            fa[j] = i;
            sz[i] += sz[j];
        }
        groups--;
    }


    int color[],dfn[],low[],stack[],cnt[];
    boolean vis[];
    boolean iscut[];
    int deep,top,n,m,sum,ans;
    List<Integer> g[];

    void tarjan(int u,int fa) {
        int child = 0;
        dfn[u]=++deep;
        low[u]=deep;
        vis[u]=true;
        stack[++top]=u;
        int sz=g[u].size();
        for(int i=0;i<sz;i++) {
            int v =g[u].get(i);
            if(v==fa) continue;
            if(dfn[v]==0) {
                child++;
                tarjan(v,u);
                low[u]=Math.min(low[u],low[v]);
            } else {
                if(vis[v]) {
                    low[u]=Math.min(low[u],low[v]);
                }
            }
        }
        if(fa<0&&child==1){
            iscut[u] =true;
        }

        if(dfn[u]==low[u]) {
            iscut[u] = true;
            color[u]=++sum;
            vis[u]=false;
            while(stack[top]!=u) {
                color[stack[top]]=sum;
                vis[stack[top--]]=false;
            }
            top--;
        }
    }


    int h[],to[],ne[];int ct =0;
    void add(int u,int v){
        u--;v--;
        to[ct] = v;
        ne[ct] = h[u];
        h[u] = ct++;
    }

    void graph(int n,int m){
        h = new int[n];
        Arrays.fill(h,-1);
        ne = new int[2*m];
        to = new int[2*m];
        ct = 0;
    }


    static long mul(long a, long b, long p)
    {
        long res=0,base=a;
        while(b>0)
        {
            if((b&1L)>0)
                res=(res+base)%p;
            base=(base+base)%p;
            b>>=1;
        }
        return res;
    }


    static long mod_pow(long k,long n,long p){
        long res = 1L;
        long temp = (k%p+p)%p;
        while(n!=0L){
            if((n&1L)==1L){
                res = ((res*temp)%p+p)%p;
            }
            temp = ((temp * temp)%p+p)%p;
            n = n>>1L;
        }
        return res%p;
    }
    public static String roundS(double result, int scale){
        String fmt = String.format("%%.%df", scale);
        return String.format(fmt, result);
    }

    int x[];
    int y[];
    int k ;
    int r = 1000000000;
    int[][] pos;

    boolean gd(int i){
        if(pos[i][0]<pos[i][1]) return false;
        if(pos[i][2]>pos[i][3]) return false;
        return true;
    }


    int area(int i){
        if(pos[i][0]<=pos[i][1]) return 0;
        if(pos[i][2]>=pos[i][3]) return 0;
        return (pos[i][0]-pos[i][1])*(pos[i][3]-pos[i][2]);
    }

    boolean in(int i,int y,int x){
        return y<=pos[i][0]&&y>=pos[i][1] && x<=pos[i][3] && x>= pos[i][2];
    }


    boolean ck(int i,int j){
        return !in(i, pos[j][0],pos[j][3]) &&
        !in(i, pos[j][0],pos[j][2]) &&
        !in(i, pos[j][1],pos[j][2]) &&
        !in(i, pos[j][1],pos[j][3]);
    }

    void go(int c,int sum){
        if(sum>=r) return;
        if(c==n){
            for(int i=0;i<k;++i) {
                if (!gd(i)) return;
            }

            for(int i=0;i<k;++i){
                for(int j=i+1;j<k;++j){
                    if(!ck(i,j)){
                        return;
                    }
                }
            }
            r = sum;
            return;
        }

        for(int i=0;i<k;++i){
            int tmp[] = pos[i].clone();
            int zx = x[c];
            int zy = y[c];

            int prev = area(i);

            pos[i][0] = Math.max(pos[i][0],zy);
            pos[i][1] = Math.min(pos[i][1],zy);

            pos[i][2] = Math.min(pos[i][2],zx);
            pos[i][3] = Math.max(pos[i][3],zx);

            int cur = area(i);

            go(c+1,sum-prev+cur);

            pos[i] = tmp;
        }

    }


    int dx[] = {0,0,1,-1};
    int dy[] = {1,-1,0,0};
    boolean xiao(int mp[][]){
        boolean ok = false;
        boolean mk[][] = new boolean[7][5];
        for(int i=0;i<7;++i){
            for(int j=0;j<5;++j){
                if(mp[i][j]==0) continue;
                int k = j+1;
                int c = mp[i][j];
                while(k<5&&mp[i][k]==c) k++;
                if(k-j>=3){
                    ok = true;
                    for(int u=j;u<k;++u){
                        mk[i][u] = true;
                    }
                }
            }
        }

        for(int i=0;i<5;++i){
            for(int j=6;j>=0;--j){
                if(mp[i][j]==0) break;
                int k = j-1;
                int c = mp[i][j];
                while(k>=0&&mp[i][k]==c) k--;
                if(j-k>=3){
                    ok = true;
                    for(int u=j;u>k;--u){
                        mk[i][u] = true;
                    }
                }
            }
        }

        for(int i=0;i<7;++i) {
            for (int j = 0; j < 5; ++j) {
                if (mp[i][j] > 0 && mk[i][j]) {
                    mp[i][j] = 0;
                }
            }
        }
      return ok;
    }

    void luo(int[][] mp){
        for(int i=0;i<5;++i){
            int f = 6;
            for(int j=6;j>=0;--j){
                if(mp[i][j]==0) continue;
                mp[i][f] = mp[i][j];f--;
                mp[i][j] = 0;
            }
        }
    }


    void go(int mp[][]){



        while(xiao(mp)){
            luo(mp);
        }



    }

    void sort(int a[]){
        Arrays.sort(a);
    }


    int gcd(int a,int b){
        return b==0?a:gcd(b,a%b);
    }

    void solve() {
//        int n = ni();
//        int mp[][] = new int[7][5];
//        // less than 10;
//
//        for(int i=0;i<5;++i){
//            int x = 6;
//            while(true){
//                int num = ni();
//                if(num==0) break;
//                mp[x][i] = num;
//                x--;
//            }
//        }
            int n = ni();
            int k = ni();
            int pos1 = -1;
            int pos2 = -1;
            StringBuilder sb = new StringBuilder();
            sb.append("? ");
            for(int i=1;i<=k;++i){
                sb.append(i);
                if(i!=k){
                    sb.append(" ");
                }
            }
            println(sb);out.flush();
            pos1 = ni();
            int a[] = new int[k+2];
            a[pos1] = ni();

        sb = new StringBuilder();
        sb.append("? ");
        for(int i=1;i<=k;++i){
            if(i==pos1) continue;
            sb.append(i);
            sb.append(" ");
        }
        sb.append(k+1);
        println(sb);out.flush();
        pos2 = ni();
        a[pos2] = ni();
        int same = 0;
        for(int skip=1;skip<=k+1;++skip) {
            if (skip == pos1 || skip == pos2) continue;
            sb = new StringBuilder();
            sb.append("? ");
            for (int i = 1; i <= k + 1; ++i) {
                if (i == pos1 || i == pos2 || i == skip) continue;
                sb.append(i);
                sb.append(" ");
            }
            sb.append(pos1+" ");
            sb.append(pos2);
            println(sb); out.flush();
            ni();
            int v =ni();
            if(v==a[pos2]){
                same++;
            }
        }

        if(a[pos1]<a[pos2]){
            println("! "+(same+1));out.flush();
        }else{
            println("! "+(k-same));out.flush();
        }
















    }





    InputStream is;
    PrintWriter out;

    void run() throws Exception {
        is = System.in;
        out = new PrintWriter(System.out);
        solve();
        out.flush();
    }

    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte() {
        if (lenbuf == -1) throw new InputMismatchException();
        if (ptrbuf >= lenbuf) {
            ptrbuf = 0;
            try {
                lenbuf = is.read(inbuf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (lenbuf <= 0) return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) {
        return !(c >= 33 && c <= 126);
    }

    private int skip() {
        int b;
        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
        return b;
    }

    private double nd() {
        return Double.parseDouble(ns());
    }

    private char nc() {
        return (char) skip();
    }

    private char ncc() {
        int b = readByte();
        return (char) b;
    }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n) {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while (p < n && !(isSpaceChar(b))) {
            buf[p++] = (char) b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private String nline() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while (!isSpaceChar(b) || b == ' ') {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[][] nm(int n, int m) {
        char[][] a = new char[n][];
        for (int i = 0; i < n; i++) a[i] = ns(m);
        return a;
    }

    private int[] na(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = ni();
        return a;
    }

    private long[] nal(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) a[i] = nl();
        return a;
    }

    private int ni() {
        int num = 0, b;
        boolean minus = false;
        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) {
        }
        ;
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        while (true) {
            if (b >= '0' && b <= '9') num = (num << 3) + (num << 1) + (b - '0');
            else return minus ? -num : num;
            b = readByte();
        }
    }

    private long nl() {
        long num = 0;
        int b;
        boolean minus = false;
        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) {
        }
        ;
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        while (true) {
            if (b >= '0' && b <= '9') num = num * 10 + (b - '0');
            else return minus ? -num : num;
            b = readByte();
        }
    }

    void print(Object obj) {
        out.print(obj);
    }

    void println(Object obj) {
        out.println(obj);
    }

    void println() {
        out.println();
    }

    void printArray(int a[],int from){
        int l = a.length;
        for(int i=from;i<l;++i){
            print(a[i]);
            if(i!=l-1){
                print(" ");
            }
        }
        println();
    }

    void printArray(long a[],int from){
        int l = a.length;
        for(int i=from;i<l;++i){
            print(a[i]);
            if(i!=l-1){
                print(" ");
            }
        }
        println();
    }
}