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].

Difficulty: HARD
Tags: Sorting

Mathematics

Constructive algorithms
Skill types: Sorting

Starter code:

Solutions:
import sys
input = sys.stdin.readline
(N, K) = map(int, input().split())

def inout(A):
	print('?', end=' ')
	print(*A)
	sys.stdout.flush()
	(pos, a) = map(int, input().split())
	return (pos, a)
dic = {}
for k in range(1, K + 2):
	A = list(range(1, k)) + list(range(k + 1, K + 2))
	(pos, a) = inout(A)
	if a in dic:
		dic[a] += 1
	else:
		dic[a] = 1
S = list(dic.items())
S.sort()
ind = S[1][1]
print('!', ind)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
from typing import List
(N, K) = map(int, input().split())
wc = collections.defaultdict(int)
for x in itertools.combinations([i for i in range(1, K + 2)], K):
	print('? {}'.format(' '.join(map(str, x))))
	sys.stdout.flush()
	(i, v) = map(int, input().split())
	wc[v] += 1
print('! {}'.format(K + 1 - wc[min(wc.keys())]))


import sys
(n, k) = map(int, input().split())
k1 = 0
k2 = 0
b1 = 0
b2 = 0
for i in range(k + 1):
	print('?', end=' ')
	for j in range(k + 1):
		if i != j:
			print(j + 1, end=' ')
	sys.stdout.flush()
	(a, x) = map(int, input().split())
	if i == 0:
		b1 = x
	if x == b1:
		k1 += 1
	else:
		b2 = x
		k2 += 1
if b1 > b2:
	print('!', k1)
else:
	print('!', k2)
sys.stdout.flush()


import sys

def query(a):
	print('?', *a)
	sys.stdout.flush()
	(p, v) = map(int, input().split())
	return (p, v)
(n, k) = map(int, input().split())
a = list(range(1, k + 1))
stack = []
for i in range(1, k + 1):
	(_, v) = query(a)
	stack.append(v)
	a[-i] += 1
(_, v) = query(a)
stack.append(v)
stack.sort()
print('!', stack.count(stack[-1]))
sys.stdout.flush()


import sys
d = {}
(n, k) = map(int, input().split())
for missing in range(1, k + 2):
	print('?', ' '.join([str(i) for i in range(1, k + 2) if i != missing]))
	sys.stdout.flush()
	(_, v) = map(int, input().split())
	if v in d:
		d[v] += 1
	else:
		d[v] = 1
a = list(d.keys())[0]
b = list(d.keys())[1]
if a > b:
	x = a
else:
	x = b
print('!', d[x])
sys.stdout.flush()


from sys import stdout
(n, k) = map(int, input().split())
(n1, n2) = (0, 0)
(e1, e2) = (-1, -1)
elems = [i + 1 for i in range(k + 1)]
for i in range(k + 1):
	print('?', *elems[:i], *elems[i + 1:k + 1])
	stdout.flush()
	(pos, elem) = map(int, input().split())
	if elem > e1:
		(e1, e2) = (elem, e1)
		(n1, n2) = (1, n1)
	elif elem == e1:
		n1 += 1
	elif elem > e2:
		e2 = elem
		n2 = 1
	elif elem == e2:
		n2 += 1
print('!', n1)
stdout.flush()


(n, k) = list(map(int, input().split()))
zapros = list()
j = 0
for i in range(1, k + 2):
	zapros.append(list())
	j += 1
	for m in range(1, k + 2):
		if i != m:
			zapros[-1].append(m)
pos = dict()
value = dict()
for i in zapros:
	print('?', *i, flush=True)
	(x, y) = map(int, input().split())
	if x in pos:
		pos[x] += 1
	else:
		pos[x] = 1
	if y in value:
		value[y] += 1
	else:
		value[y] = 1
val = 0
ans = 0
for i in value:
	if i >= val:
		val = i
		ans = value[i]
print('!', ans, flush=True)


from sys import stdout
(n, k) = map(int, input().split())
ans = []
low = -1
high = -1
for i in range(k + 1):
	print('? ', end='')
	for x in range(1, k + 2):
		if x != i + 1:
			print(x, end=' ')
	print()
	stdout.flush()
	v = list(map(int, input().split()))
	ans.append(v)
	if low == -1:
		low = v[1]
	if low != v[1]:
		high = v[1]
if low > high:
	(low, high) = (high, low)
m = 0
for x in ans:
	if x[1] == high:
		m += 1
print(f'! {m}')
stdout.flush()


import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
from collections import defaultdict
mod = 10 ** 9 + 7
mod1 = 998244353
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

class TreeNode:

	def __init__(self, k, v):
		self.key = k
		self.value = v
		self.left = None
		self.right = None
		self.parent = None
		self.height = 1
		self.num_left = 1
		self.num_total = 1

class AvlTree:

	def __init__(self):
		self._tree = None

	def add(self, k, v):
		if not self._tree:
			self._tree = TreeNode(k, v)
			return
		node = self._add(k, v)
		if node:
			self._rebalance(node)

	def _add(self, k, v):
		node = self._tree
		while node:
			if k < node.key:
				if node.left:
					node = node.left
				else:
					node.left = TreeNode(k, v)
					node.left.parent = node
					return node.left
			elif node.key < k:
				if node.right:
					node = node.right
				else:
					node.right = TreeNode(k, v)
					node.right.parent = node
					return node.right
			else:
				node.value = v
				return

	@staticmethod
	def get_height(x):
		return x.height if x else 0

	@staticmethod
	def get_num_total(x):
		return x.num_total if x else 0

	def _rebalance(self, node):
		n = node
		while n:
			lh = self.get_height(n.left)
			rh = self.get_height(n.right)
			n.height = max(lh, rh) + 1
			balance_factor = lh - rh
			n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
			n.num_left = 1 + self.get_num_total(n.left)
			if balance_factor > 1:
				if self.get_height(n.left.left) < self.get_height(n.left.right):
					self._rotate_left(n.left)
				self._rotate_right(n)
			elif balance_factor < -1:
				if self.get_height(n.right.right) < self.get_height(n.right.left):
					self._rotate_right(n.right)
				self._rotate_left(n)
			else:
				n = n.parent

	def _remove_one(self, node):
		replacement = node.left or node.right
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = replacement
			else:
				node.parent.right = replacement
			replacement.parent = node.parent
			node.parent = None
		else:
			self._tree = replacement
			replacement.parent = None
		node.left = None
		node.right = None
		node.parent = None
		self._rebalance(replacement)

	def _remove_leaf(self, node):
		if node.parent:
			if AvlTree._is_left(node):
				node.parent.left = None
			else:
				node.parent.right = None
			self._rebalance(node.parent)
		else:
			self._tree = None
		node.parent = None
		node.left = None
		node.right = None

	def remove(self, k):
		node = self._get_node(k)
		if not node:
			return
		if AvlTree._is_leaf(node):
			self._remove_leaf(node)
			return
		if node.left and node.right:
			nxt = AvlTree._get_next(node)
			node.key = nxt.key
			node.value = nxt.value
			if self._is_leaf(nxt):
				self._remove_leaf(nxt)
			else:
				self._remove_one(nxt)
			self._rebalance(node)
		else:
			self._remove_one(node)

	def get(self, k):
		node = self._get_node(k)
		return node.value if node else -1

	def _get_node(self, k):
		if not self._tree:
			return None
		node = self._tree
		while node:
			if k < node.key:
				node = node.left
			elif node.key < k:
				node = node.right
			else:
				return node
		return None

	def get_at(self, pos):
		x = pos + 1
		node = self._tree
		while node:
			if x < node.num_left:
				node = node.left
			elif node.num_left < x:
				x -= node.num_left
				node = node.right
			else:
				return (node.key, node.value)
		raise IndexError('Out of ranges')

	@staticmethod
	def _is_left(node):
		return node.parent.left and node.parent.left == node

	@staticmethod
	def _is_leaf(node):
		return node.left is None and node.right is None

	def _rotate_right(self, node):
		if not node.parent:
			self._tree = node.left
			node.left.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.left
			node.left.parent = node.parent
		else:
			node.parent.right = node.left
			node.left.parent = node.parent
		bk = node.left.right
		node.left.right = node
		node.parent = node.left
		node.left = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	def _rotate_left(self, node):
		if not node.parent:
			self._tree = node.right
			node.right.parent = None
		elif AvlTree._is_left(node):
			node.parent.left = node.right
			node.right.parent = node.parent
		else:
			node.parent.right = node.right
			node.right.parent = node.parent
		bk = node.right.left
		node.right.left = node
		node.parent = node.right
		node.right = bk
		if bk:
			bk.parent = node
		node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
		node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
		node.num_left = 1 + self.get_num_total(node.left)

	@staticmethod
	def _get_next(node):
		if not node.right:
			return node.parent
		n = node.right
		while n.left:
			n = n.left
		return n

class SegmentTree1:

	def __init__(self, data, default='z', func=lambda a, b: min(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: a + b):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)

class Factorial:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorials = [1, 1]
		self.invModulos = [0, 1]
		self.invFactorial_ = [1, 1]

	def calc(self, n):
		if n <= -1:
			print('Invalid argument to calculate n!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.factorials):
			return self.factorials[n]
		nextArr = [0] * (n + 1 - len(self.factorials))
		initialI = len(self.factorials)
		prev = self.factorials[-1]
		m = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * i % m
		self.factorials += nextArr
		return self.factorials[n]

	def inv(self, n):
		if n <= -1:
			print('Invalid argument to calculate n^(-1)')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		p = self.MOD
		pi = n % p
		if pi < len(self.invModulos):
			return self.invModulos[pi]
		nextArr = [0] * (n + 1 - len(self.invModulos))
		initialI = len(self.invModulos)
		for i in range(initialI, min(p, n + 1)):
			next = -self.invModulos[p % i] * (p // i) % p
			self.invModulos.append(next)
		return self.invModulos[pi]

	def invFactorial(self, n):
		if n <= -1:
			print('Invalid argument to calculate (n^(-1))!')
			print('n must be non-negative value. But the argument was ' + str(n))
			exit()
		if n < len(self.invFactorial_):
			return self.invFactorial_[n]
		self.inv(n)
		nextArr = [0] * (n + 1 - len(self.invFactorial_))
		initialI = len(self.invFactorial_)
		prev = self.invFactorial_[-1]
		p = self.MOD
		for i in range(initialI, n + 1):
			prev = nextArr[i - initialI] = prev * self.invModulos[i % p] % p
		self.invFactorial_ += nextArr
		return self.invFactorial_[n]

class Combination:

	def __init__(self, MOD):
		self.MOD = MOD
		self.factorial = Factorial(MOD)

	def ncr(self, n, k):
		if k < 0 or n < k:
			return 0
		k = min(k, n - k)
		f = self.factorial
		return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD

def powm(a, n, m):
	if a == 1 or n == 0:
		return 1
	if n % 2 == 0:
		s = powm(a, n // 2, m)
		return s * s % m
	else:
		return a * powm(a, n - 1, m) % m

def sort_list(list1, list2):
	zipped_pairs = zip(list2, list1)
	z = [x for (_, x) in sorted(zipped_pairs)]
	return z

def product(l):
	por = 1
	for i in range(len(l)):
		por *= l[i]
	return por

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] < key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def countdig(n):
	c = 0
	while n > 0:
		n //= 10
		c += 1
	return c

def binary(x, length):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y

def countGreater(arr, n, k):
	l = 0
	r = n - 1
	leftGreater = n
	while l <= r:
		m = int(l + (r - l) / 2)
		if arr[m] >= k:
			leftGreater = m
			r = m - 1
		else:
			l = m + 1
	return n - leftGreater
(n, k1) = map(int, input().split())
a = [i + 1 for i in range(k1 + 1)]
d = defaultdict(int)
for i in range(k1 + 1):
	a1 = a[:i] + a[i + 1:]
	print('?', *a1, flush=True)
	(a1, k) = map(int, input().split())
	d[k] += 1
m = 0
c = 0
l = list(d.keys())
if d[l[0]] > d[l[1]]:
	ind = l[0]
	ind1 = l[1]
else:
	ind = l[1]
	ind1 = l[0]
if ind > ind1:
	print('!', k1 - d[ind1] + 1)
else:
	print('!', d[ind1])


from sys import stdout
(n, k) = map(int, input().split())
a = {}
for i in range(1, k + 2):
	q = '?'
	for j in range(1, k + 2):
		if j != i:
			q += ' ' + str(j)
	print(q)
	stdout.flush()
	(p, ap) = map(int, input().split())
	if ap not in a:
		a[ap] = 0
	a[ap] += 1
ma = max(a.keys())
m = a[ma]
print('!', m)


import math
import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
arr = []
count = []
for i in range(k + 1):
	pos = ['?']
	for j in range(k + 1):
		if j != i:
			pos.append(j + 1)
	print(*pos)
	sys.stdout.flush()
	(pos, num) = map(int, input().split())
	if num not in arr:
		arr.append(num)
		count.append(1)
	else:
		y = arr.index(num)
		count[y] += 1
if arr[0] > arr[1]:
	print('!', count[0])
else:
	print('!', count[1])


def query(a):
	print('?', *a, flush=True)
	(pos, val) = map(int, input().split())
	return (pos, val)

def printAns(ans):
	print('! %d' % ans, flush=True)
(n, k) = map(int, input().split())
res = []
for i in range(1, k + 2):
	a = list(filter(lambda x: x != i, range(1, k + 2)))
	(pos, val) = query(a)
	res.append(val)
printAns(res.count(max(res)))


import sys
import collections

def inp(dtype=str, strip=True):
	s = input()
	res = [dtype(p) for p in s.split()]
	res = res[0] if len(res) == 1 and strip else res
	return res

def problem4():
	(n, k) = inp(int)
	known_count = collections.defaultdict(lambda : 0)
	known_pos = dict()
	s = set(range(1, k + 2))
	for missing in range(1, k + 2):
		s.remove(missing)
		query = ['{:d}'.format(el) for el in s]
		query = ' '.join(query)
		query = '? {}'.format(query)
		print(query)
		sys.stdout.flush()
		(pos, el) = inp(int)
		known_pos[el] = pos
		known_count[el] += 1
		s.add(missing)
	mx = max(known_count.keys())
	res = known_count[mx]
	res = '! {:d}'.format(res)
	print(res)
	sys.stdout.flush()
problem4()


from sys import stdout
from collections import defaultdict
d = defaultdict(int)
(n, k) = map(int, input().split())
for i in range(1, k + 2):
	array = ['?']
	for j in range(1, k + 2):
		if j != i:
			array.append(j)
	print(*array)
	stdout.flush()
	(pos, apos) = map(int, input().split())
	d[apos] += 1
element = max(d.keys())
print('!', d[element])


from sys import stdout
(n, k) = map(int, input().split())
l = [str(i + 1) for i in range(k + 1)]
outs = dict()
for i in range(k + 1):
	copy = l[:]
	copy.pop(i)
	print('?', ' '.join(copy))
	stdout.flush()
	(ind, val) = map(int, input().split())
	if val not in outs:
		outs[val] = 0
	outs[val] += 1
tol = outs[max(outs.keys())]
print('!', tol)
stdout.flush()


from collections import Counter
(n, k) = map(int, input().split())
for x in range(1, k + 2):
	print('?', *(y for y in range(1, k + 2) if y != x))
cnt = Counter((int(input().split()[1]) for _ in range(k + 1)))
print('!', cnt[max(cnt.keys())])


(n, k) = [int(j) for j in input().split()]
from collections import defaultdict
dic = defaultdict(lambda : 0)
for i in range(k + 1):
	l = [int(j) for j in range(1, k + 2)]
	l.remove(i + 1)
	print('?', *l)
	(x, y) = [int(j) for j in input().split()]
	dic[y] += 1
print('!', dic[max(dic)])


import sys
(n, k) = map(int, input().split())
q = [i + 1 for i in range(k + 1)]
a = [None] * n
ind = 0
dic = {}
exist = []
for i in range(k + 1):
	query = '?'
	for j in range(k + 1):
		if i != j:
			query += ' '
			query += str(q[j])
	print(query, flush=True)
	(pos, num) = map(int, input().split())
	if num not in exist:
		exist.append(num)
		dic[num] = 1
	else:
		dic[num] += 1
exist.sort()
print('!', dic[exist[-1]], flush=True)


import sys
import collections
(n, k) = map(int, input().split())
valc = collections.defaultdict(int)
lc = list(range(1, k + 2))
for i in range(k + 1):
	print('?', end=' ')
	for e in lc[:i] + lc[i + 1:]:
		print(e, end=' ')
	print('')
	sys.stdout.flush()
	(pos, val) = map(int, input().split())
	valc[val] += 1
mxk = max(valc.keys())
print('!', valc[mxk])
sys.stdout.flush()


import sys
import math
from collections import defaultdict, Counter
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, k) = map(int, input().split())
l = []
ma = 0
for j in range(1, k + 2):
	print('?', end=' ', flush=True)
	for kk in range(1, k + 2):
		if kk != j:
			print(kk, end=' ', flush=True)
	(ind, el) = map(int, input().split())
	l.append(el)
	ma = max(ma, el)
	print()
print('!', l.count(ma), flush=True)


(n, k) = map(int, input().split())
pos_count = {}
pos_a_pos = {}
i_skip_value = [0 for _ in range(k + 1)]
for i_skip in range(k + 1):
	print('? ' + ' '.join([str(i + 1) for i in range(k + 1) if i != i_skip]), flush=True)
	s = input().split()
	if len(s) == 1:
		exit()
	(pos, a_pos) = map(int, s)
	if pos in pos_count:
		pos_count[pos] += 1
	else:
		pos_count[pos] = 1
	pos_a_pos[pos] = a_pos
	i_skip_value[i_skip] = a_pos
if len(pos_count) != 2:
	exit()
(main_pos, side_pos) = (list(pos_count.keys())[0], list(pos_count.keys())[1])
if pos_count[main_pos] < pos_count[side_pos]:
	(main_pos, side_pos) = (side_pos, main_pos)
main_value = pos_a_pos[main_pos]
side_value = pos_a_pos[side_pos]
min_count = pos_count[side_pos]
(ans1, ans2) = (min_count, k + 1 - min_count)
if ans1 == ans2:
	print('! {}'.format(ans1), flush=True)
else:
	if main_value > side_value:
		ans = ans2
	else:
		ans = ans1
	print('! {}'.format(ans), flush=True)


(n, k) = map(int, input().split())
first_value = None
first_count = 0
second_value = None
second_count = 0
for i in range(1, k + 2):
	a = [y for y in range(1, k + 2)]
	a.remove(i)
	print('? ' + ' '.join(map(str, a)), flush=True)
	(_, ans) = map(int, input().split())
	if first_value == None or first_value == ans:
		first_value = ans
		first_count += 1
	elif second_value == None or second_value == ans:
		second_value = ans
		second_count += 1
if first_value > second_value:
	print('! ' + str(first_count), flush=True)
else:
	print('! ' + str(second_count), flush=True)


import sys
(n, k) = [int(x) for x in input().split()]
x = 0
y = 0
a = []
for i in range(1, k + 2):
	print('?', end=' ')
	for j in range(1, k + 2):
		if j != i:
			print(j, end=' ')
	print()
	sys.stdout.flush()
	(x, y) = [int(x) for x in input().split()]
	a.append(y)
s = set(a)
b = list(s)
x = a.count(b[0])
y = a.count(b[1])
if b[0] > b[1]:
	print('!', x)
else:
	print('!', y)


import sys

def solution():
	(n, k) = [int(i) for i in input().strip().split()]
	foo = '? ' + ' '.join([str(i + 1) for i in range(k)]) + ' '
	bar = ' ' + str(k + 1) + ' '
	sys.stdout.write(foo.strip() + '\n')
	sys.stdout.flush()
	(p, w) = [int(i) - 1 for i in input().strip().split()]
	(lt, eq, gt) = (0, 0, 0)
	for i in range(k):
		if i == p:
			continue
		sys.stdout.write(foo.replace(' ' + str(i + 1) + ' ', bar).strip() + '\n')
		sys.stdout.flush()
		(q, v) = [int(i) - 1 for i in input().strip().split()]
		if v < w:
			lt += 1
		elif v > w:
			gt += 1
		else:
			eq += 1
	if lt != 0:
		sys.stdout.write('! %d\n' % (k - lt))
		sys.stdout.flush()
		return
	elif gt != 0:
		sys.stdout.write('! %d\n' % (gt + 1))
		sys.stdout.flush()
		return
	sys.stdout.write(foo.replace(' ' + str(p + 1) + ' ', bar).strip() + '\n')
	(q, v) = [int(i) - 1 for i in input().strip().split()]
	if v < w:
		sys.stdout.write('! %d\n' % k)
		sys.stdout.flush()
	else:
		sys.stdout.write('! %d\n' % 1)
		sys.stdout.flush()

def main():
	solution()
main()


from sys import stdout
(n, k) = list(map(int, input().split()))
(value1, value2) = (-1, -1)
(count1, count2) = (0, 0)
for i in range(1, k + 2):
	query = ['?']
	for j in range(1, k + 2):
		if i != j:
			query.append(j)
	print(*query)
	stdout.flush()
	(a, b) = list(map(int, input().split()))
	if i == 1:
		value1 = b
	elif value2 == -1 and b != value1:
		value2 = b
	if value1 == b:
		count1 += 1
	elif value2 == b:
		count2 += 1
if value1 > value2:
	(count1, count2) = (count2, count1)
print('!', k + 1 - count1)


import sys
input = sys.stdin.readline

def query(li):
	print('?', *li)
	sys.stdout.flush()
	(res, num) = map(int, input().split())
	return num
(n, k) = map(int, input().split())
ans = []
for i in range(k + 1):
	li = []
	for j in range(k + 1):
		if j == i:
			continue
		li.append(j + 1)
	num = query(li)
	ans.append(num)
	max_ans = max(ans)
cnt = 0
for i in ans:
	if max_ans == i:
		cnt += 1
print('!', cnt)


from sys import stdout
from collections import defaultdict

def make_query(l):
	s = ['?']
	for i in l:
		s.append(str(i))
	print(' '.join(s))
	stdout.flush()
	(idx, element) = map(int, input().split())
	return (idx, element)
(n, k) = map(int, input().split())
respuestas = defaultdict(int)
for j in range(1, k + 2):
	(idx, element) = make_query([i for i in range(1, k + 2) if i != j])
	respuestas[element, idx] += 1
print('! {}'.format(respuestas[max(respuestas)]))
stdout.flush()


import sys
(n, k) = map(int, input().split())
a = [i for i in range(1, k + 2)]
b = []
mp = {}
for i in range(1, k + 2):
	a.remove(i)
	print('? ' + ' '.join((str(_) for _ in a)))
	a.append(i)
	sys.stdout.flush()
	(pos, v) = map(int, input().split())
	if v not in b:
		b.append(v)
		mp[v] = 1
	else:
		mp[v] += 1
b.sort()
print('! ', mp[b[1]], sep='')


import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
s = 0
sf = 0
l = 0
lf = 0
for i in range(1, k + 2):
	q = '?'
	for j in range(1, k + 2):
		if i != j:
			q += ' '
			q += str(j)
	print(q, flush=True)
	(a, b) = map(int, input().split())
	if s == 0:
		s = b
		sf += 1
	elif b == s:
		sf += 1
	else:
		l = b
		lf += 1
if l > s:
	print('!', lf, flush=True)
else:
	print('!', sf, flush=True)


from sys import stdout
(n, k) = map(int, input().split())
ans = [[i + 1 for i in range(k + 1)] for j in range(k + 1)]
d = []
for i in range(k + 1):
	a = ans[i]
	a.remove(i + 1)
	print('?', *a)
	stdout.flush()
	(a, b) = list(map(int, input().split()))
	d.append(b)
ans = len(d)
m = min(d)
for i in d:
	if i == m:
		ans -= 1
print('!', ans)


import sys, math
MOD = 998244353
(n, k) = map(int, input().split())
x = {i for i in range(1, k + 2)}
(f, a) = ({}, {})
ps = set()
for i in range(1, k + 2):
	ask = x - {i}
	print('?', *ask)
	sys.stdout.flush()
	(pos, apos) = map(int, input().split())
	a[pos] = apos
	ps.add(pos)
	if pos in f:
		f[pos] += 1
	else:
		f[pos] = 1
(x, y) = list(ps)
if a[x] > a[y]:
	print('!', f[x])
else:
	print('!', f[y])


def rli():
	return list(map(int, input().split()))

def main():
	(n, k) = rli()
	nums = []
	for i in range(1, k + 2):
		tmp = ['?']
		for j in range(1, k + 2):
			if j != i:
				tmp.append(j)
		print(' '.join(map(str, tmp)))
		nums.append(rli()[1])
	nums.sort()
	maxc = len(list(filter(lambda x: x == nums[-1], nums)))
	minc = len(list(filter(lambda x: x == nums[0], nums)))
	diff = len(nums) - max(maxc, minc)
	ans = None
	if maxc > minc:
		ans = k - diff + 1
	else:
		ans = diff
	print('!', ans)
main()


from sys import stdout
(n, k) = map(int, input().split())
data = {}
vals = list(range(1, k + 1))
for i in reversed(range(k + 1)):
	if i != k:
		vals[i] += 1
	print('? {:s}'.format(' '.join(map(str, vals))))
	stdout.flush()
	(p, v) = map(int, input().split())
	if not v in data:
		data[v] = 0
	data[v] += 1
m = None
mm = 0
for (v, k) in data.items():
	if v > mm:
		mm = v
		m = k
print('! {:d}'.format(m))
stdout.flush()


(n, k) = map(int, input().split())
D = {}
for i in range(k + 1):
	Q = [''] * (k + 1)
	Q[0] = '?'
	t = 1
	for j in range(k + 1):
		if j != i:
			Q[t] = j + 1
			t += 1
	print(' '.join([str(i) for i in Q]), flush=True)
	(a, b) = map(int, input().split())
	try:
		D[b] += 1
	except:
		D[b] = 1
E = list(D.keys())
ans = 0
if E[0] > E[1]:
	ans = D[E[0]]
else:
	ans = D[E[1]]
print('! ' + str(ans))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

def lcm(a, b):
	return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if not True else 1):
	(n, k) = map(int, input().split())
	di = {}
	for qq in range(1, k + 2):
		a = [i for i in range(1, k + 2) if i != qq]
		print('?', *a, flush=True)
		(ind, x) = map(int, input().split())
		if x in di:
			di[x] += 1
		else:
			di[x] = 1
	print('!', di[max([k for k in di])], flush=True)


import sys
(n, k) = map(int, input().split())
vis = [0] * n
dd = []
for i in range(k + 1):
	print('?', end=' ')
	for j in range(k + 1):
		if i == j:
			continue
		print(j + 1, end=' ')
	print()
	sys.stdout.flush()
	(pos, apos) = map(int, input().split())
	dd.append(apos)
print('!', dd.count(max(dd)))
exit(0)


(n, k) = map(int, input().split())
if k == 1:
	print('!', 1)
else:
	print('?', *[i + 1 for i in range(k)])
	(pos, val) = map(int, input().split())
	less = 0
	more = 0
	ambiguity = 0
	f = False
	flag = False
	for i in range(k):
		if i + 1 != pos:
			a = [j + 1 for j in range(k)]
			a[i] = k + 1
			print('?', *a)
			(p, v) = map(int, input().split())
			if p == pos:
				ambiguity += 1
			elif p == k + 1:
				if v > val:
					f = True
					flag = True
					less += 1
				else:
					f = True
					flag = False
					more += 1
			elif v > val:
				f = True
				flag = True
				less += 1
			else:
				f = True
				flag = False
				more += 1
	if f:
		if flag:
			print('!', less + 1)
		else:
			print('!', less + ambiguity + 1)
	else:
		a = [i + 1 for i in range(k)]
		a[pos - 1] = k + 1
		print('?', *a)
		(p, v) = map(int, input().split())
		if val > v:
			print('!', k)
		else:
			print('!', 1)


from collections import Counter
from sys import stdin, stdout

def rl():
	return [int(w) for w in stdin.readline().split()]
(n, k) = rl()
c = Counter()
for i in range(1, k + 2):
	print('?', *(j for j in range(1, k + 2) if j != i))
	stdout.flush()
	(pos, apos) = rl()
	c[apos] += 1
h = max(c.keys())
print('!', c[h])


import sys, os, io
from collections import defaultdict
(n, k) = [int(i) for i in input().split()]
cnt = defaultdict(lambda : 0)
ask = set()
for i in range(1, k + 2):
	ask.add(i)
for i in range(1, k + 2):
	ask.remove(i)
	print('?', *ask)
	(pos, apos) = [int(i) for i in input().split()]
	cnt[apos] += 1
	ask.add(i)
maxi = max(cnt)
print('!', cnt[maxi])


import sys

def print(s='', end='\n'):
	sys.stdout.write(str(s) + end)

def input():
	return sys.stdin.readline().rstrip()
(n, k) = map(int, input().split())
ans = []
for i in range(k + 1):
	print('?', end=' ')
	for j in range(k + 1):
		if j != i:
			print(j + 1, end=' ')
	print()
	sys.stdout.flush()
	ans.append(list(map(int, input().split()))[1])
maxn = -1
app = 0
for i in ans:
	if i > maxn:
		maxn = i
		app = 1
	elif i == maxn:
		app += 1
print('! ' + str(app))
sys.stdout.flush()


import sys
input = sys.stdin.readline
from collections import defaultdict

def ask(lst):
	print('?', *lst)
	sys.stdout.flush()
	return tuple(map(int, input().split()))

def ans(m):
	print('!', m)
	sys.stdout.flush()
(n, k) = map(int, input().split())
a = list(range(1, k + 2))
d = defaultdict(int)
for i in range(1, k + 2):
	lst = set(a) - set([i])
	(k, ak) = ask(lst)
	d[ak] += 1
key = sorted(d.keys())[1]
m = d[key]
ans(m)


from sys import stdin, stdout
import math
from bisect import bisect_left, bisect_right
input = lambda : stdin.readline().strip()
print = lambda s: stdout.write(s)
(n, k) = map(int, input().split())
ls = []
for i in range(k + 1):
	print('? ')
	for j in range(k + 1):
		if j != i:
			print(str(j + 1) + ' ')
	print('\n')
	stdout.flush()
	(a, b) = map(int, input().split())
	ls.append(b)
M = max(ls)
cnt = 0
for i in ls:
	if i == M:
		cnt += 1
print('! ' + str(cnt) + '\n')


from collections import defaultdict

def ask_k(a, i):
	b = a[:]
	b.remove(a[i])
	print('?', end=' ')
	for j in range(k):
		print(b[j], end=' ')
	print()
(n, k) = map(int, input().split())
a = [i for i in range(1, n + 1)]
d = defaultdict(int)
for i in range(k + 1):
	ask_k(a, i)
	(pos, val) = map(int, input().split())
	d[val] += 1
mx = max(d)
print('!', d[mx])


class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

class OrderedList(SortedList):

	def __init__(self, arg):
		super().__init__(arg)

	def rangeCountByValue(self, leftVal, rightVal):
		leftCummulative = self.bisect_left(leftVal)
		rightCummulative = self.bisect_left(rightVal + 1)
		return rightCummulative - leftCummulative

def profileGenerator(n, k, m, simulationArr):
	simulatedProfile = []
	ol = OrderedList(simulationArr[:k])
	l = 0
	r = k
	for _ in range(n):
		simulatedProfile.append(ol[m - 1])
		ol.remove(simulationArr[l % n])
		ol.add(simulationArr[r % n])
		l += 1
		r += 1
	simulatedProfile.sort()
	return simulatedProfile

def compareProfiles(profile1, profile2, n):
	for i in range(1, n):
		oneChanged = False
		twoChanged = False
		if profile1[i] != profile1[i - 1]:
			oneChanged = True
		if profile2[i] != profile2[i - 1]:
			twoChanged = True
		if oneChanged != twoChanged:
			return False
	return True

def main():
	(n, k) = readIntArr()
	n = k + 1
	simulationArr = list(range(n))
	actualProfile = []
	for i in range(n):
		start = i
		end = i + k - 1
		arr = []
		for j in range(start, end + 1):
			arr.append(1 + j % n)
		(pos, value) = queryInteractive2(arr)
		actualProfile.append(value)
	actualProfile.sort()
	for m in range(1, k + 1):
		generatedProfile = profileGenerator(n, k, m, simulationArr)
		if compareProfiles(actualProfile, generatedProfile, n):
			answerInteractive(m)
			break
	return
import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')

def oneLineArrayPrint(arr):
	print(' '.join([str(x) for x in arr]))

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))

def multiLineArrayOfArraysPrint(arr):
	print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
	return [int(x) for x in input().split()]

def makeArr(defaultVal, dimensionArr):
	dv = defaultVal
	da = dimensionArr
	if len(da) == 1:
		return [dv for _ in range(da[0])]
	else:
		return [makeArr(dv, da[1:]) for _ in range(da[0])]

def queryInteractive(x, y):
	print('? {} {}'.format(x, y))
	sys.stdout.flush()
	return int(input())

def queryInteractive2(arr):
	print('? ' + ' '.join([str(x) for x in arr]))
	sys.stdout.flush()
	return [int(x) for x in input().split()]

def answerInteractive(ans):
	print('! {}'.format(ans))
	sys.stdout.flush()
inf = float('inf')
MOD = 10 ** 9 + 7
for _abc in range(1):
	main()


import sys
(n, k) = map(int, input().split())
kek = [i for i in range(1, k + 2)]
used = []
ans = {}
for i in range(k + 1):
	print('?', end=' ')
	print(*kek[:i], *kek[i + 1:])
	sys.stdout.flush()
	(p, num) = map(int, input().split())
	if num not in used:
		if used:
			m1 = max(num, used[0])
			m0 = min(num, used[0])
			ans[num] = 1
			used.append(num)
		else:
			used.append(num)
			ans[num] = 1
	else:
		ans[num] += 1
print('!', ans[m1])


import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
x = sys.stdout.flush
if k == 1:
	print('!', 1)
	x()
else:
	vis = [0 for i in range(n)]
	arr = [i + 1 for i in range(n)]
	st = 1
	mi = -1
	mi_ind = 1
	ma = float('inf')
	ma_inf = 1
	for i in range(n - k + 1):
		arr = [i + 1 for i in range(n) if vis[i] == 0][:k]
		print('?', *arr)
		x()
		try:
			(ind, val) = map(int, input().split())
			vis[ind - 1] = 1
			if val > mi:
				mi = val
				mi_ind = ind
			if val < ma:
				ma = val
				ma_ind = ind
		except:
			st = 0
			break
	if st:
		do = [i + 1 for i in range(n) if vis[i] == 0]
		stt = []
		do.append(ma_ind)
		do.append(mi_ind)
		co = k - 1
		for i in range(k - 1):
			dd = [do[j] for j in range(k + 1) if do[j] != do[i]]
			print('?', *dd)
			x()
			(ind, val) = map(int, input().split())
			if val == ma:
				co -= 1
		print('!', co + 1)
		x()


from sys import stdout
from collections import Counter

def solved():
	(n, k) = (int(x) for x in input().split())
	arr = list(range(1, k + 2))
	val___count = Counter()
	for excluded in range(k + 1):
		req = ['?'] + arr[:excluded] + arr[excluded + 1:]
		print(*req)
		stdout.flush()
		(idx, val) = (int(x) for x in input().split())
		val___count[val] += 1
	x = max(val___count)
	print('!', val___count[x])
	stdout.flush()

def solvec():
	n = int(input())
	arr = [int(x) for x in input().split()]
	xor = 0
	for x in arr:
		xor ^= x
	arr.append(xor)
	sm = sum(arr)
	arr.append(sm)
	print(2)
	print(xor, sm)
t = 1
for _ in range(t):
	solved()


import sys
(n, k) = map(int, input().split())

def guess(arr):
	print(*['?'] + arr)
	sys.stdout.flush()
	(pos, val) = map(int, input().split())
	return val
odp = ['chuj']
for i in range(1, k + 2):
	lis = list(range(1, k + 2))
	lis.pop(i - 1)
	new = guess(lis)
	odp.append(new)
x = max(odp[1:])
print('!', odp.count(x))


import sys
(n, m) = map(int, input().split())
lis = []
for i in range(1, m + 2):
	print('?', end=' ')
	for j in range(1, m + 2):
		if i != j:
			print(j, end=' ')
	print()
	(a, b) = map(int, input().split())
	sys.stdout.flush()
	lis.append(b)
aa = max(lis)
ans = 0
for i in lis:
	if i == aa:
		ans += 1
print('!', ans)


(n, k) = map(int, input().split())
results = {}
for i in range(k + 1):
	q = [j + 1 for j in range(k + 1) if j != i]
	qq = ' '.join(map(str, q))
	print(f'? {qq}', flush=True)
	(pos, apos) = map(int, input().split())
	results[apos] = results.get(apos, 0) + 1
print(f'! {results[max(results)]}', flush=True)


(a, b) = [int(x) for x in input().split()]
l = []
for j in range(1, b + 2):
	print('?', end=' ')
	for i in range(1, b + 2):
		if i != j:
			print(i, end=' ')
	print(flush=True)
	(c, d) = [int(x) for x in input().split()]
	l.append(d)
l.sort()
p = l.count(l[0])
q = l.count(l[-1])
if q > p:
	print('!', q)
else:
	print('!', b - p + 1)


(n, k) = list(map(int, input().split()))
values = []
for i in range(1, k + 2):
	x = list(range(1, i)) + list(range(i + 1, k + 2))
	print('?', *x)
	(position, a) = map(int, input().split())
	values.append(a)
small = min(values)
large = max(values)
m = len([a for a in values if a == large])
print('!', m)


import collections
(N, K) = map(int, input().split())
cnum = collections.defaultdict(int)
mnum = 2000000000
for i in range(1, K + 2):
	req = [j for j in range(1, K + 2) if j != i]
	print('? %s' % ' '.join(map(str, req)), flush=True)
	(pos, apos) = map(int, input().split())
	mnum = min(mnum, apos)
	cnum[apos] += 1
ans = K + 1 - cnum[mnum]
print('! %d' % ans, flush=True)


from sys import stdout
(n, k) = [int(k) for k in input().strip().split(' ')]
stl = list(range(1, k + 1))
if k == 1:
	print('! 1')
	exit()
print(' '.join(['?'] + [str(i) for i in stl]))
stdout.flush()
a = {}
(j, v) = [int(k) for k in input().strip().split(' ')]
a[j] = v
pivot = 1
while pivot == j:
	pivot += 1
cotes = [0] * (n + 1)
cotes[pivot] = 1
for i in range(k + 1, n + 1):
	tc = [ii if ii != pivot else i for ii in stl]
	print(' '.join(['?'] + [str(ii) for ii in tc]))
	stdout.flush()
	(jj, vv) = [int(k) for k in input().strip().split(' ')]
	a[jj] = vv
	if j == jj:
		cotes[i] = cotes[pivot]
	else:
		cotes[i] = -cotes[pivot]
newpivot = n
for i in range(1, k + 1):
	if i != j and i != pivot:
		tc = [ii if ii != i else newpivot for ii in stl]
		print(' '.join(['?'] + [str(ii) for ii in tc]))
		stdout.flush()
		(jj, vv) = [int(k) for k in input().strip().split(' ')]
		a[jj] = vv
		if j == jj:
			cotes[i] = cotes[newpivot]
		else:
			cotes[i] = -cotes[newpivot]
if len(a) == 1:
	tc = [ii for ii in range(1, k + 2) if ii != j]
	print(' '.join(['?'] + [str(ii) for ii in tc]))
	stdout.flush()
	(jj, vv) = [int(k) for k in input().strip().split(' ')]
	a[jj] = vv
realcotes = [0] * (n + 1)
for kk in a:
	if kk != j:
		realcotes[kk] = 1 if a[kk] > a[j] else -1
		for ii in range(1, n + 1):
			realcotes[ii] = cotes[ii] * cotes[kk] * realcotes[kk]
		break
m = 1
for i in range(1, k + 1):
	if realcotes[i] < 0:
		m += 1
print('! {}'.format(m))
stdout.flush()


from functools import cmp_to_key
from collections import deque, Counter
from heapq import heappush, heappop
from math import log, ceil
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def ii():
	return int(inp())

def si():
	return str(inp())

def li(lag=0):
	l = list(map(int, inp().split()))
	if lag != 0:
		for i in range(len(l)):
			l[i] += lag
	return l

def mi(lag=0):
	matrix = list()
	for i in range(n):
		matrix.append(li(lag))
	return matrix

def lsi():
	return list(map(str, inp().split()))

def print_list(lista, space=' ', **kwargs):
	print(space.join(map(str, lista)), **kwargs)

def bisect_left(a, x):
	left = 0
	right = len(a)
	while left < right:
		mid = (left + right) // 2
		if a[mid] < x:
			left = mid + 1
		else:
			right = mid
	return left

def bisect_right(a, x):
	left = 0
	right = len(a)
	while left < right:
		mid = (left + right) // 2
		if a[mid] > x:
			right = mid
		else:
			left = mid + 1
	return left

def bisect_elements(a, x):
	return bisect_right(a, x) - bisect_left(a, x)
MOD = 10 ** 9 + 7
maxN = 5
FACT = [0] * maxN
INV_FACT = [0] * maxN

def add(x, y):
	return (x + y) % MOD

def multiply(x, y):
	return x * y % MOD

def power(x, y):
	if y == 0:
		return 1
	elif y % 2:
		return multiply(x, power(x, y - 1))
	else:
		a = power(x, y // 2)
		return multiply(a, a)

def inverse(x):
	return power(x, MOD - 2)

def divide(x, y):
	return multiply(x, inverse(y))

def allFactorials():
	FACT[0] = 1
	for i in range(1, maxN):
		FACT[i] = multiply(i, FACT[i - 1])

def inverseFactorials():
	n = len(INV_FACT)
	INV_FACT[n - 1] = inverse(FACT[n - 1])
	for i in range(n - 2, -1, -1):
		INV_FACT[i] = multiply(INV_FACT[i + 1], i + 1)

def coeffBinom(n, k):
	if n < k:
		return 0
	return multiply(FACT[n], multiply(INV_FACT[k], INV_FACT[n - k]))

def create_graph(n, m, undirected=1, unweighted=1):
	graph = [[] for i in range(n)]
	if unweighted:
		for i in range(m):
			[x, y] = li(lag=-1)
			graph[x].append(y)
			if undirected:
				graph[y].append(x)
	else:
		for i in range(m):
			[x, y, w] = li(lag=-1)
			w += 1
			graph[x].append([y, w])
			if undirected:
				graph[y].append([x, w])
	return graph

def create_tree(n, unweighted=1):
	children = [[] for i in range(n)]
	if unweighted:
		for i in range(n - 1):
			[x, y] = li(lag=-1)
			children[x].append(y)
			children[y].append(x)
	else:
		for i in range(n - 1):
			[x, y, w] = li(lag=-1)
			w += 1
			children[x].append([y, w])
			children[y].append([x, w])
	return children

def dist(tree, n, A, B=-1):
	s = [[A, 0]]
	(massimo, massimo_nodo) = (0, 0)
	distanza = -1
	v = [-1] * n
	while s:
		(el, dis) = s.pop()
		if dis > massimo:
			massimo = dis
			massimo_nodo = el
		if el == B:
			distanza = dis
		for child in tree[el]:
			if v[child] == -1:
				v[child] = 1
				s.append([child, dis + 1])
	return (massimo, massimo_nodo, distanza)

def diameter(tree):
	(_, foglia, _) = dist(tree, n, 0)
	(diam, _, _) = dist(tree, n, foglia)
	return diam

def dfs(graph, n, A):
	v = [-1] * n
	s = [[A, 0]]
	v[A] = 0
	while s:
		(el, dis) = s.pop()
		for child in graph[el]:
			if v[child] == -1:
				v[child] = dis + 1
				s.append([child, dis + 1])
	return v

def bfs(graph, n, A):
	v = [-1] * n
	s = deque()
	s.append([A, 0])
	v[A] = 0
	while s:
		(el, dis) = s.popleft()
		for child in graph[el]:
			if v[child] == -1:
				v[child] = dis + 1
				s.append([child, dis + 1])
	return v

def parents_children_root_unrooted_tree(tree, n, root=0):
	q = deque()
	visited = [0] * n
	parent = [-1] * n
	children = [[] for i in range(n)]
	q.append(root)
	while q:
		all_done = 1
		visited[q[0]] = 1
		for child in tree[q[0]]:
			if not visited[child]:
				all_done = 0
				q.appendleft(child)
		if all_done:
			for child in tree[q[0]]:
				if parent[child] == -1:
					parent[q[0]] = child
					children[child].append(q[0])
			q.popleft()
	return (parent, children)

def all_longest_path_passing_from_node(parent, children, n):
	q = deque()
	visited = [len(children[i]) for i in range(n)]
	downwards = [[0, 0] for i in range(n)]
	upward = [1] * n
	longest_path = [1] * n
	for i in range(n):
		if not visited[i]:
			q.append(i)
			downwards[i] = [1, 0]
	while q:
		node = q.popleft()
		if parent[node] != -1:
			visited[parent[node]] -= 1
			if not visited[parent[node]]:
				q.append(parent[node])
		else:
			root = node
		for child in children[node]:
			downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse=True)[0:2]
	s = [node]
	while s:
		node = s.pop()
		if parent[node] != -1:
			if downwards[parent[node]][0] == downwards[node][0] + 1:
				upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
			else:
				upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
		longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
		for child in children[node]:
			s.append(child)
	return longest_path
[n, k] = li()
occ = dict()
for i in range(k + 1):
	q = ['?']
	for j in range(k + 1):
		if j != i:
			q.append(j + 1)
	print_list(q, flush=True)
	(pos, num) = li()
	occ[pos, num] = occ.get((pos, num), 0) + 1
ma = 0
freq = 0
for (pos, num) in occ:
	if num > ma:
		ma = num
		freq = occ[pos, num]
print_list(['!', freq], flush=True)


from sys import stdout
(n, k) = map(int, input().split())
ans = n
kek = [0] * (k + 1)
real = 10 ** 9 + 1
reali = -1
for i in range(k + 1):
	print('?', end=' ')
	for j in range(k + 1):
		if i != j:
			print(j + 1, end=' ')
	print()
	stdout.flush()
	(kek[i], a) = map(int, input().split())
	if a < real:
		real = a
		reali = kek[i]
cnt = 0
for i in range(k + 1):
	if kek[i] == reali:
		cnt += 1
print('!', k + 1 - cnt)
stdout.flush()


from sys import stdout
T = 1
for t in range(1, T + 1):
	low = set([])
	high = set([])
	k_1_group = set([])
	(n, k) = map(int, input().split())
	print('? ', end='')
	print(*list(range(1, k + 1)))
	stdout.flush()
	(x, a_x) = map(int, input().split())
	k_1 = 0
	for i in range(1, k + 1):
		if i == x:
			continue
		print('? ', end='')
		for j in range(1, k + 2):
			if j != i:
				print(j, end=' ')
		print('')
		stdout.flush()
		(y, a_y) = map(int, input().split())
		if y == x:
			if k_1 == 0:
				k_1_group.add(i)
			elif k_1 == 1:
				low.add(i)
			else:
				high.add(i)
		elif a_y < a_x:
			high.add(i)
			k_1 = 1
		else:
			low.add(i)
			k_1 = 2
	if k_1 == 0 and len(k_1_group):
		print('? ', end='')
		for j in range(1, k + 2):
			if j != x:
				print(j, end=' ')
		print('')
		stdout.flush()
		(y, a_y) = map(int, input().split())
		if a_y < a_x:
			k_1 = 1
		else:
			k_1 = 2
	if k_1 == 1:
		for i in k_1_group:
			low.add(i)
	print('!', len(low) + 1)


from math import *
from collections import *
import sys
sys.setrecursionlimit(10 ** 9)
(n, k) = map(int, input().split())
ct1 = ct2 = 0
ans1 = ans2 = -1
for i in range(k + 1):
	print('?', end=' ')
	for j in range(k + 1):
		if i == j:
			continue
		print(j + 1, end=' ')
	print()
	(ind, ans) = map(int, input().split())
	if ans1 == -1:
		ans1 = ans
		ct1 += 1
	elif ans == ans1:
		ct1 += 1
	elif ans2 == -1:
		ans2 = ans
		ct2 += 1
	else:
		ct2 += 1
	sys.stdout.flush()
if ans1 > ans2:
	print('!', k + 1 - ct2)
else:
	print('!', k + 1 - ct1)


def main():
	(n, k) = readIntArr()
	cnts = dict()
	for i in range(k + 1):
		start = i
		end = i + k - 1
		arr = []
		for j in range(start, end + 1):
			arr.append(1 + j % (k + 1))
		(pos, value) = queryInteractive2(arr)
		if value not in cnts.keys():
			cnts[value] = 0
		cnts[value] += 1
	(x, y) = cnts.keys()
	larger = max(x, y)
	m = cnts[larger]
	answerInteractive(m)
	return
import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')

def oneLineArrayPrint(arr):
	print(' '.join([str(x) for x in arr]))

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))

def multiLineArrayOfArraysPrint(arr):
	print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
	return [int(x) for x in input().split()]

def makeArr(defaultVal, dimensionArr):
	dv = defaultVal
	da = dimensionArr
	if len(da) == 1:
		return [dv for _ in range(da[0])]
	else:
		return [makeArr(dv, da[1:]) for _ in range(da[0])]

def queryInteractive(x, y):
	print('? {} {}'.format(x, y))
	sys.stdout.flush()
	return int(input())

def queryInteractive2(arr):
	print('? ' + ' '.join([str(x) for x in arr]))
	sys.stdout.flush()
	return [int(x) for x in input().split()]

def answerInteractive(ans):
	print('! {}'.format(ans))
	sys.stdout.flush()
inf = float('inf')
MOD = 10 ** 9 + 7
for _abc in range(1):
	main()


import sys
(n, k) = [int(x) for x in input().split()]
ind = [i for i in range(1, k + 2)]
n = k + 1
fnd_sub_arr = []
for i in range(k + 1):
	sub_ind = ind[:i] + ind[i + 1:]
	print('?', *sub_ind)
	sys.stdout.flush()
	(fnd_ind, fnd_el) = [int(x) for x in input().split()]
	fnd_sub_arr.append(fnd_el)
bm1 = max(fnd_sub_arr)
cnt = 0
for i in fnd_sub_arr:
	if bm1 == i:
		cnt += 1
print('!', cnt)
sys.stdout.flush()


import sys
(n, k) = map(int, input().split())
dic = {}
exist = []
for i in range(k + 1):
	query = '? '
	query += ' '.join([str(ele + 1) for ele in range(k + 1) if ele != i])
	print(query, flush=True)
	(pos, num) = map(int, input().split())
	if num not in exist:
		exist.append(num)
		dic[num] = 1
	else:
		dic[num] += 1
exist.sort()
print('!', dic[exist[-1]], flush=True)


from math import *
import os, sys
from bisect import *
from io import BytesIO
sys.setrecursionlimit(10 ** 9)

def f1():
	sys.stdout.flush()
(n, k) = map(int, input().split())
if k == 1:
	print('!', 1)
	exit(0)
print('?', end=' ')
a = [0] * n
x = set(range(1, k + 2))
print(*x - {1})
f1()
(p, c) = map(int, input().split())
a[p - 1] = c
d = {}
d[c] = 1
for i in range(2, k + 2):
	print('?', end=' ')
	print(*x - {i})
	f1()
	(p, c1) = map(int, input().split())
	d[c1] = d.get(c1, 0) + 1
a = d.keys()
x1 = min(a)
print('!', k - d[x1] + 1)


import sys
(n, k) = list(map(int, input().split()))
query = [i + 1 for i in range(k + 1)]
x = []
for i in range(k + 1):
	new = query[:]
	del new[i]
	print('?', *new)
	sys.stdout.flush()
	(pos, apos) = list(map(int, input().split()))
	x.append(apos)
y = list(set(x))
if y[0] > y[1]:
	print('!', x.count(y[0]))
else:
	print('!', x.count(y[1]))


from sys import stdin, stdout
input = stdin.buffer.readline
(n, k) = map(int, input().split())

def ask(a):
	print('?', *[i for i in range(1, k + 2) if i != a], flush=True)
	return [int(i) for i in input().split()][1]
cnt = {}
for i in range(1, k + 2):
	x = ask(i)
	cnt[x] = cnt.get(x, 0) + 1
print('!', cnt[max(cnt)], flush=True)


import sys, random, functools

def req(idxs):
	print('?', *idxs)
	sys.stdout.flush()
	(pos, a_pos) = map(int, input().split())
	return (a_pos, pos)
(n, k) = map(int, input().split())
res = [[0] * (k + 1) for i in range(k + 1)]
answers = [0] * (k + 1)
know = [-1] * (k + 1)
for i in range(k + 1):
	(a, p) = req([j for j in range(1, k + 2) if j - 1 != i])
	know[p - 1] = a
	answers[i] = a
bm = max(answers)
print('!', answers.count(bm))


import sys
from collections import Counter

def input():
	return sys.stdin.readline().rstrip()

def input_ints():
	return [int(_) for _ in input().split()]

def flush():
	sys.stdout.flush()
(n, k) = input_ints()
cnt = Counter()
for i in range(k + 1):
	qs = (str(j + 1) for j in range(k + 1) if i != j)
	print('? %s' % ' '.join(qs))
	flush()
	(p, v) = input_ints()
	cnt[v] += 1
ans = sorted(cnt.items())[1][1]
print('! %s' % ans)


import sys
(x, y) = map(int, input().strip().split())
inputlist = []
inputdict = {}
for i in range(y + 1):
	printlist = []
	for j in range(y):
		a = (i + j) % (y + 1)
		if a == 0:
			a = y + 1
		printlist.append(str(a))
	print('? ' + ' '.join(printlist))
	sys.stdout.flush()
	(s, t) = map(int, input().strip().split())
	if t in inputlist:
		inputdict[t] += 1
	else:
		inputdict[t] = 1
	inputlist.append(t)
y = max(inputlist)
print('! ' + str(inputdict[y]))


import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())

def emit(x):
	print('?', ' '.join(map(str, x)))
	sys.stdout.flush()
	s = minp().split()
	if len(s) == 1:
		s.append('-1')
	(a, b) = map(int, s)
	return (b, a)

def emit1(x):
	z = []
	for j in x:
		z.append((a[j - 1], j))
	z.sort()
	s = z[m - 1]
	return tuple(map(int, s))

def solve():
	(n, k) = mints()
	w = []
	for i in range(k + 1):
		x = []
		for j in range(k + 1):
			if i != j:
				x.append(j + 1)
		y = emit(x)
		if y[0] == -1:
			return
		w.append(y)
	w.sort(reverse=True)
	i = 0
	while w[i] == w[0]:
		i += 1
	print('!', i)
	sys.stdout.flush()
solve()


(n, k) = [int(i) for i in input().split()]
elements = []
for a in range(k + 1):
	query = list(range(1, k + 2))
	del query[a]
	print('?', ' '.join([str(i) for i in query]), flush=True)
	resp = [int(i) for i in input().split()]
	elements.append(resp[1])
elements = sorted(elements)
for i in range(1, len(elements)):
	if elements[i] != elements[i - 1]:
		print('!', k + 1 - i, flush=True)


import sys
(n, k) = map(int, input().split())
d = {}
for i in range(1, k + 2):
	a = ['?']
	for j in range(1, k + 2):
		if j is not i:
			a.append(j)
	print(' '.join(map(str, a)))
	sys.stdout.flush()
	(pos, x) = map(int, input().split())
	if x not in d:
		d[x] = 1
	else:
		d[x] += 1
a = [(x, d[x]) for x in d]
a = sorted(a)
print('!', a[1][1])
sys.stdout.flush()


(n, k) = list(map(int, input().strip().split()))
x = []
for i in range(1, k + 2):
	print('? ' + ' '.join([str(x) for x in range(1, k + 2) if x != i]))
	(a, b) = list(map(int, input().strip().split()))
	x.append(b)
z = 0
xx = max(x)
for i in x:
	if i == xx:
		z += 1
print('! ' + str(z))


from sys import stdout
from collections import Counter

def main():
	(_, k) = map(int, input().split())
	answers = Counter()
	for i in range(1, k + 2):
		q = [j for j in range(1, k + 2) if j != i]
		print('? ', ' '.join(map(str, q)))
		stdout.flush()
		(_, a) = map(int, input().split())
		answers[a] += 1
	alm = max(answers.most_common())
	print('!', alm[1])
main()


from collections import Counter

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]
(n, k) = li()
cnt = Counter()
curr = [i + 1 for i in range(k + 1)]
for i in range(1, k + 2):
	curr.remove(i)
	print('?', *curr, flush=1)
	(pos, ele) = li()
	cnt[ele] += 1
	curr.append(i)
print('!', cnt[max(cnt)])