description: It turns out that the meaning of life is a permutation p_1, p_2, …, p_n of the integers 1, 2, …, n (2 ≤ n ≤ 100). Omkar, having created all life, knows this permutation, and will allow you to figure it out using some queries.
  
  A query consists of an array a_1, a_2, …, a_n of integers between 1 and n. a is not required to be a permutation. Omkar will first compute the pairwise sum of a and p, meaning that he will compute an array s where s_j = p_j + a_j for all j = 1, 2, …, n. Then, he will find the smallest index k such that s_k occurs more than once in s, and answer with k. If there is no such index k, then he will answer with 0.
  
  You can perform at most 2n queries. Figure out the meaning of life p.
  
  Interaction
  
  Start the interaction by reading single integer n (2 ≤ n ≤ 100) — the length of the permutation p.
  
  You can then make queries. A query consists of a single line "? \enspace a_1 \enspace a_2 \enspace … \enspace a_n" (1 ≤ a_j ≤ n).
  
  The answer to each query will be a single integer k as described above (0 ≤ k ≤ n).
  
  After making 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.
  
  
  
  To output your answer, print a single line "! \enspace p_1 \enspace p_2 \enspace … \enspace p_n" then terminate.
  
  You can make at most 2n queries. Outputting the answer does not count as a query.
  
  Hack Format
  
  To hack, first output a line containing n (2 ≤ n ≤ 100), then output another line containing the hidden permutation p_1, p_2, …, p_n of numbers from 1 to n.
  
  Example
  
  Input
  
  
  5
  
  2
  
  0
  
  1
  
  
  Output
  
  
  
  ? 4 4 2 3 2
  
  ? 3 5 1 5 5
  
  ? 5 2 4 3 1
  
  ! 3 2 1 5 4
  
  Note
  
  In the sample, the hidden permutation p is [3, 2, 1, 5, 4]. Three queries were made.
  
  The first query is a = [4, 4, 2, 3, 2]. This yields s = [3 + 4, 2 + 4, 1 + 2, 5 + 3, 4 + 2] = [7, 6, 3, 8, 6]. 6 is the only number that appears more than once, and it appears first at index 2, making the answer to the query 2.
  
  The second query is a = [3, 5, 1, 5, 5]. This yields s = [3 + 3, 2 + 5, 1 + 1, 5 + 5, 4 + 5] = [6, 7, 2, 10, 9]. There are no numbers that appear more than once here, so the answer to the query is 0.
  
  The third query is a = [5, 2, 4, 3, 1]. This yields s = [3 + 5, 2 + 2, 1 + 4, 5 + 3, 4 + 1] = [8, 4, 5, 8, 5]. 5 and 8 both occur more than once here. 5 first appears at index 3, while 8 first appears at index 1, and 1 < 3, making the answer to the query 1.
  
  Note that the sample is only meant to provide an example of how the interaction works; it is not guaranteed that the above queries represent a correct strategy with which to determine the answer.
solution: import static java.lang.Math.max;
  import static java.lang.Math.min;
  import static java.lang.Math.abs;
  import java.util.*;
  import java.io.*;
  import java.math.*;
  
  /**
   *
   * @Har_Har_Mahadev
   */
  
  /**
   * Main , Solution , Remove Public
   */
  public class D {
  
  	public static void process() throws IOException {
  
  		int n = sc.nextInt();
  		StringBuilder ans = new StringBuilder();
  		for(int i =0; i+1<n; i++)ans.append(n+" ");
  		int last = 1;
  		for(int i = n; i>=2; i--) {
  			ask(ans,i,n);
  			int a = sc.nextInt();
  			if(a == 0)continue;
  			last = i;
  			break;
  		}
  		int res[] = new int[n+1];
  		res[n] = last;
  		ans = new StringBuilder();
  		for(int i = 0; i+1<n; i++)ans.append("1 ");
  		for(int i = last+1; i<=n; i++) {
  			int val = i-last+1;
  			ask1(ans, val);
  			int a = sc.nextInt();
  			res[a] = i;
  		}
  		
  		for(int i = last-1; i>=1; i--) {
  			int val = last-i+1;
  			ask2(val,n);
  			int a = sc.nextInt();
  			res[a] = i;
  		}
  		
  		ans = new StringBuilder();
  		ans.append("! ");
  		
  		for(int i = 1; i<=n; i++) {
  			ans.append(res[i]+" ");
  		}
  		System.out.println(ans);
  
  	}
  
  	private static void ask2(int val, int n) {
  		StringBuilder ans = new StringBuilder();
  		for(int i = 1; i<n; i++)ans.append(val+" ");
  		ans.append(1);
  		System.out.println("? "+ans);
  	}
  
  	private static void ask1(StringBuilder ans, int add) {
  		StringBuilder mm = new StringBuilder();
  		mm.append(ans);
  		mm.append(add);
  		System.out.println("? "+mm);
  		
  	}
  
  	private static void ask(StringBuilder ans, int i, int n) {
  		StringBuilder mm = new StringBuilder();
  		mm.append(ans);
  		int vv = n+1-i;
  		mm.append(vv);
  		System.out.println("? "+mm);
  	}
  
  	//=============================================================================
  	//--------------------------The End---------------------------------
  	//=============================================================================
  	private static long INF = 2000000000000000000L, M = 1000000007, MM = 998244353;
  	private static int N = 0;
  
  	private static void google(int tt) {
  		System.out.print("Case #" + (tt) + ": ");
  	}
  
  	static FastScanner sc;
  	static FastWriter out;
  
  	public static void main(String[] args) throws IOException {
  		boolean oj = true;
  		if (oj) {
  			sc = new FastScanner();
  			out = new FastWriter(System.out);
  		} else {
  			sc = new FastScanner("input.txt");
  			out = new FastWriter("output.txt");
  		}
  		long s = System.currentTimeMillis();
  		int t = 1;
  //		t = sc.nextInt();
  		int TTT = 1;
  		while (t-- > 0) {
  			//			google(TTT++);
  			process();
  		}
  		out.flush();
  		//		tr(System.currentTimeMillis()-s+"ms");
  	}
  
  	private static boolean oj = System.getProperty("ONLINE_JUDGE") != null;
  
  	private static void tr(Object... o) {
  		if (!oj)
  			System.err.println(Arrays.deepToString(o));
  	}
  
  	static class Pair implements Comparable<Pair> {
  		int x, y;
  
  		Pair(int x, int y) {
  			this.x = x;
  			this.y = y;
  		}
  
  		@Override
  		public int compareTo(Pair o) {
  			return Integer.compare(this.x, o.x);
  		}
  
  		/*
  		 	@Override
  		    public boolean equals(Object o) {
  		        if (this == o) return true;
  		        if (!(o instanceof Pair)) return false;
  		        Pair key = (Pair) o;
  		        return x == key.x && y == key.y;
  		    }
  		 
  		    @Override
  		    public int hashCode() {
  		        int result = x;
  		        result = 31 * result + y;
  		        return result;
  		    }
  		*/
  	}
  
  	/////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  	static int ceil(int x, int y) {
  		return (x % y == 0 ? x / y : (x / y + 1));
  	}
  
  	static long ceil(long x, long y) {
  		return (x % y == 0 ? x / y : (x / y + 1));
  	}
  
  	static long sqrt(long z) {
  		long sqz = (long) Math.sqrt(z);
  		while (sqz * 1L * sqz < z) {
  			sqz++;
  		}
  		while (sqz * 1L * sqz > z) {
  			sqz--;
  		}
  		return sqz;
  	}
  
  	static int log2(int N) {
  		int result = (int) (Math.log(N) / Math.log(2));
  		return result;
  	}
  
  	public static long gcd(long a, long b) {
  		if (a > b)
  			a = (a + b) - (b = a);
  		if (a == 0L)
  			return b;
  		return gcd(b % a, a);
  	}
  
  	public static long lcm(long a, long b) {
  		return (a * b) / gcd(a, b);
  	}
  
  	public static int lower_bound(int[] arr, int x) {
  		int low = 0, high = arr.length - 1, mid = -1;
  		int ans = -1;
  		while (low <= high) {
  			mid = (low + high) / 2;
  
  			if (arr[mid] > x) {
  				high = mid - 1;
  			} else {
  				ans = mid;
  				low = mid + 1;
  			}
  		}
  
  		return ans;
  	}
  
  	public static int upper_bound(int[] arr, int x) {
  		int low = 0, high = arr.length - 1, mid = -1;
  		int ans = arr.length;
  		while (low < high) {
  			mid = (low + high) / 2;
  
  			if (arr[mid] >= x) {
  				ans = mid;
  				high = mid - 1;
  			} else {
  				low = mid + 1;
  			}
  		}
  
  		return ans;
  	}
  
  	static void ruffleSort(int[] a) {
  		Random get = new Random();
  		for (int i = 0; i < a.length; i++) {
  			int r = get.nextInt(a.length);
  			int temp = a[i];
  			a[i] = a[r];
  			a[r] = temp;
  		}
  		Arrays.sort(a);
  	}
  
  	static void ruffleSort(long[] a) {
  		Random get = new Random();
  		for (int i = 0; i < a.length; i++) {
  			int r = get.nextInt(a.length);
  			long temp = a[i];
  			a[i] = a[r];
  			a[r] = temp;
  		}
  		Arrays.sort(a);
  	}
  
  	static void reverseArray(int[] a) {
  		int n = a.length;
  		int arr[] = new int[n];
  		for (int i = 0; i < n; i++)
  			arr[i] = a[n - i - 1];
  		for (int i = 0; i < n; i++)
  			a[i] = arr[i];
  	}
  
  	static void reverseArray(long[] a) {
  		int n = a.length;
  		long arr[] = new long[n];
  		for (int i = 0; i < n; i++)
  			arr[i] = a[n - i - 1];
  		for (int i = 0; i < n; i++)
  			a[i] = arr[i];
  	}
  
  	//custom multiset (replace with HashMap if needed)
  	public static void push(TreeMap<Integer, Integer> map, int k, int v) {
  		//map[k] += v;
  		if (!map.containsKey(k))
  			map.put(k, v);
  		else
  			map.put(k, map.get(k) + v);
  	}
  
  	public static void pull(TreeMap<Integer, Integer> map, int k, int v) {
  		//assumes map[k] >= v
  		//map[k] -= v
  		int lol = map.get(k);
  		if (lol == v)
  			map.remove(k);
  		else
  			map.put(k, lol - v);
  	}
  
  	// compress Big value to Time Limit
  	public static int[] compress(int[] arr) {
  		ArrayList<Integer> ls = new ArrayList<Integer>();
  		for (int x : arr)
  			ls.add(x);
  		Collections.sort(ls);
  		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
  		int boof = 1; //min value
  		for (int x : ls)
  			if (!map.containsKey(x))
  				map.put(x, boof++);
  		int[] brr = new int[arr.length];
  		for (int i = 0; i < arr.length; i++)
  			brr[i] = map.get(arr[i]);
  		return brr;
  	}
  
  	// Fast Writer 
  
  	public static class FastWriter {
  		private static final int BUF_SIZE = 1 << 13;
  		private final byte[] buf = new byte[BUF_SIZE];
  		private final OutputStream out;
  		private int ptr = 0;
  
  		private FastWriter() {
  			out = null;
  		}
  
  		public FastWriter(OutputStream os) {
  			this.out = os;
  		}
  
  		public FastWriter(String path) {
  			try {
  				this.out = new FileOutputStream(path);
  			} catch (FileNotFoundException e) {
  				throw new RuntimeException("FastWriter");
  			}
  		}
  
  		public FastWriter write(byte b) {
  			buf[ptr++] = b;
  			if (ptr == BUF_SIZE)
  				innerflush();
  			return this;
  		}
  
  		public FastWriter write(char c) {
  			return write((byte) c);
  		}
  
  		public FastWriter write(char[] s) {
  			for (char c : s) {
  				buf[ptr++] = (byte) c;
  				if (ptr == BUF_SIZE)
  					innerflush();
  			}
  			return this;
  		}
  
  		public FastWriter write(String s) {
  			s.chars().forEach(c -> {
  				buf[ptr++] = (byte) c;
  				if (ptr == BUF_SIZE)
  					innerflush();
  			});
  			return this;
  		}
  
  		private static int countDigits(int l) {
  			if (l >= 1000000000)
  				return 10;
  			if (l >= 100000000)
  				return 9;
  			if (l >= 10000000)
  				return 8;
  			if (l >= 1000000)
  				return 7;
  			if (l >= 100000)
  				return 6;
  			if (l >= 10000)
  				return 5;
  			if (l >= 1000)
  				return 4;
  			if (l >= 100)
  				return 3;
  			if (l >= 10)
  				return 2;
  			return 1;
  		}
  
  		public FastWriter write(int x) {
  			if (x == Integer.MIN_VALUE) {
  				return write((long) x);
  			}
  			if (ptr + 12 >= BUF_SIZE)
  				innerflush();
  			if (x < 0) {
  				write((byte) '-');
  				x = -x;
  			}
  			int d = countDigits(x);
  			for (int i = ptr + d - 1; i >= ptr; i--) {
  				buf[i] = (byte) ('0' + x % 10);
  				x /= 10;
  			}
  			ptr += d;
  			return this;
  		}
  
  		private static int countDigits(long l) {
  			if (l >= 1000000000000000000L)
  				return 19;
  			if (l >= 100000000000000000L)
  				return 18;
  			if (l >= 10000000000000000L)
  				return 17;
  			if (l >= 1000000000000000L)
  				return 16;
  			if (l >= 100000000000000L)
  				return 15;
  			if (l >= 10000000000000L)
  				return 14;
  			if (l >= 1000000000000L)
  				return 13;
  			if (l >= 100000000000L)
  				return 12;
  			if (l >= 10000000000L)
  				return 11;
  			if (l >= 1000000000L)
  				return 10;
  			if (l >= 100000000L)
  				return 9;
  			if (l >= 10000000L)
  				return 8;
  			if (l >= 1000000L)
  				return 7;
  			if (l >= 100000L)
  				return 6;
  			if (l >= 10000L)
  				return 5;
  			if (l >= 1000L)
  				return 4;
  			if (l >= 100L)
  				return 3;
  			if (l >= 10L)
  				return 2;
  			return 1;
  		}
  
  		public FastWriter write(long x) {
  			if (x == Long.MIN_VALUE) {
  				return write("" + x);
  			}
  			if (ptr + 21 >= BUF_SIZE)
  				innerflush();
  			if (x < 0) {
  				write((byte) '-');
  				x = -x;
  			}
  			int d = countDigits(x);
  			for (int i = ptr + d - 1; i >= ptr; i--) {
  				buf[i] = (byte) ('0' + x % 10);
  				x /= 10;
  			}
  			ptr += d;
  			return this;
  		}
  
  		public FastWriter write(double x, int precision) {
  			if (x < 0) {
  				write('-');
  				x = -x;
  			}
  			x += Math.pow(10, -precision) / 2;
  			//		if(x < 0){ x = 0; }
  			write((long) x).write(".");
  			x -= (long) x;
  			for (int i = 0; i < precision; i++) {
  				x *= 10;
  				write((char) ('0' + (int) x));
  				x -= (int) x;
  			}
  			return this;
  		}
  
  		public FastWriter writeln(char c) {
  			return write(c).writeln();
  		}
  
  		public FastWriter writeln(int x) {
  			return write(x).writeln();
  		}
  
  		public FastWriter writeln(long x) {
  			return write(x).writeln();
  		}
  
  		public FastWriter writeln(double x, int precision) {
  			return write(x, precision).writeln();
  		}
  
  		public FastWriter write(int... xs) {
  			boolean first = true;
  			for (int x : xs) {
  				if (!first)
  					write(' ');
  				first = false;
  				write(x);
  			}
  			return this;
  		}
  
  		public FastWriter write(long... xs) {
  			boolean first = true;
  			for (long x : xs) {
  				if (!first)
  					write(' ');
  				first = false;
  				write(x);
  			}
  			return this;
  		}
  
  		public FastWriter writeln() {
  			return write((byte) '\n');
  		}
  
  		public FastWriter writeln(int... xs) {
  			return write(xs).writeln();
  		}
  
  		public FastWriter writeln(long... xs) {
  			return write(xs).writeln();
  		}
  
  		public FastWriter writeln(char[] line) {
  			return write(line).writeln();
  		}
  
  		public FastWriter writeln(char[]... map) {
  			for (char[] line : map)
  				write(line).writeln();
  			return this;
  		}
  
  		public FastWriter writeln(String s) {
  			return write(s).writeln();
  		}
  
  		private void innerflush() {
  			try {
  				out.write(buf, 0, ptr);
  				ptr = 0;
  			} catch (IOException e) {
  				throw new RuntimeException("innerflush");
  			}
  		}
  
  		public void flush() {
  			innerflush();
  			try {
  				out.flush();
  			} catch (IOException e) {
  				throw new RuntimeException("flush");
  			}
  		}
  
  		public FastWriter print(byte b) {
  			return write(b);
  		}
  
  		public FastWriter print(char c) {
  			return write(c);
  		}
  
  		public FastWriter print(char[] s) {
  			return write(s);
  		}
  
  		public FastWriter print(String s) {
  			return write(s);
  		}
  
  		public FastWriter print(int x) {
  			return write(x);
  		}
  
  		public FastWriter print(long x) {
  			return write(x);
  		}
  
  		public FastWriter print(double x, int precision) {
  			return write(x, precision);
  		}
  
  		public FastWriter println(char c) {
  			return writeln(c);
  		}
  
  		public FastWriter println(int x) {
  			return writeln(x);
  		}
  
  		public FastWriter println(long x) {
  			return writeln(x);
  		}
  
  		public FastWriter println(double x, int precision) {
  			return writeln(x, precision);
  		}
  
  		public FastWriter print(int... xs) {
  			return write(xs);
  		}
  
  		public FastWriter print(long... xs) {
  			return write(xs);
  		}
  
  		public FastWriter println(int... xs) {
  			return writeln(xs);
  		}
  
  		public FastWriter println(long... xs) {
  			return writeln(xs);
  		}
  
  		public FastWriter println(char[] line) {
  			return writeln(line);
  		}
  
  		public FastWriter println(char[]... map) {
  			return writeln(map);
  		}
  
  		public FastWriter println(String s) {
  			return writeln(s);
  		}
  
  		public FastWriter println() {
  			return writeln();
  		}
  	}
  
  	// Fast Inputs
  	static class FastScanner {
  		//I don't understand how this works lmao
  		private int BS = 1 << 16;
  		private char NC = (char) 0;
  		private byte[] buf = new byte[BS];
  		private int bId = 0, size = 0;
  		private char c = NC;
  		private double cnt = 1;
  		private BufferedInputStream in;
  
  		public FastScanner() {
  			in = new BufferedInputStream(System.in, BS);
  		}
  
  		public FastScanner(String s) {
  			try {
  				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
  			} catch (Exception e) {
  				in = new BufferedInputStream(System.in, BS);
  			}
  		}
  
  		private char getChar() {
  			while (bId == size) {
  				try {
  					size = in.read(buf);
  				} catch (Exception e) {
  					return NC;
  				}
  				if (size == -1)
  					return NC;
  				bId = 0;
  			}
  			return (char) buf[bId++];
  		}
  
  		public int nextInt() {
  			return (int) nextLong();
  		}
  
  		public int[] readArray(int N) {
  			int[] res = new int[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = (int) nextLong();
  			}
  			return res;
  		}
  
  		public long[] readArrayLong(int N) {
  			long[] res = new long[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = nextLong();
  			}
  			return res;
  		}
  
  		public int[][] readArrayMatrix(int N, int M, int Index) {
  			if (Index == 0) {
  				int[][] res = new int[N][M];
  				for (int i = 0; i < N; i++) {
  					for (int j = 0; j < M; j++)
  						res[i][j] = (int) nextLong();
  				}
  				return res;
  			}
  			int[][] res = new int[N][M];
  			for (int i = 1; i <= N; i++) {
  				for (int j = 1; j <= M; j++)
  					res[i][j] = (int) nextLong();
  			}
  			return res;
  
  		}
  
  		public long[][] readArrayMatrixLong(int N, int M, int Index) {
  			if (Index == 0) {
  				long[][] res = new long[N][M];
  				for (int i = 0; i < N; i++) {
  					for (int j = 0; j < M; j++)
  						res[i][j] = nextLong();
  				}
  				return res;
  			}
  			long[][] res = new long[N][M];
  			for (int i = 1; i <= N; i++) {
  				for (int j = 1; j <= M; j++)
  					res[i][j] = nextLong();
  			}
  			return res;
  
  		}
  
  		public long nextLong() {
  			cnt = 1;
  			boolean neg = false;
  			if (c == NC)
  				c = getChar();
  			for (; (c < '0' || c > '9'); c = getChar()) {
  				if (c == '-')
  					neg = true;
  			}
  			long res = 0;
  			for (; c >= '0' && c <= '9'; c = getChar()) {
  				res = (res << 3) + (res << 1) + c - '0';
  				cnt *= 10;
  			}
  			return neg ? -res : res;
  		}
  
  		public double nextDouble() {
  			double cur = nextLong();
  			return c != '.' ? cur : cur + nextLong() / cnt;
  		}
  
  		public double[] readArrayDouble(int N) {
  			double[] res = new double[N];
  			for (int i = 0; i < N; i++) {
  				res[i] = nextDouble();
  			}
  			return res;
  		}
  
  		public String next() {
  			StringBuilder res = new StringBuilder();
  			while (c <= 32)
  				c = getChar();
  			while (c > 32) {
  				res.append(c);
  				c = getChar();
  			}
  			return res.toString();
  		}
  
  		public String nextLine() {
  			StringBuilder res = new StringBuilder();
  			while (c <= 32)
  				c = getChar();
  			while (c != '\n') {
  				res.append(c);
  				c = getChar();
  			}
  			return res.toString();
  		}
  
  		public boolean hasNext() {
  			if (c > 32)
  				return true;
  			while (true) {
  				c = getChar();
  				if (c == NC)
  					return false;
  				else if (c > 32)
  					return true;
  			}
  		}
  	}
  
  }
  