#include<bits/stdc++.h>
using namespace std;
// строка -- это последовательность чисел от 1 до размера алфавита
std::vector<int> suffix_array (std::vector<int> s) {
	if (s.size() == 1) return {0};
    s.push_back(0);  // добавляем нулевой символ в конец строки
    int n = (int) s.size(),
        cnt = 0,  // вспомогательная переменная: счётчик для сортировки 
        cls = 0;  // количество классов эквивалентности
    std::vector<int> c(n), p(n);
    
    std::map< int, std::vector<int> > t;
    for (int i = 0; i < n; i++)
        t[s[i]].push_back(i);
    
    // «нулевой» этап
    for (auto &x : t) {
        for (int u : x.second)
            c[u] = cls, p[cnt++] = u;
        cls++;
    }
    
    // пока все суффиксы не стали уникальными
    for (int l = 1; cls < n; l++) {
        std::vector<std::vector<int> > a(cls);  // массив для сортировки подсчётом
        std::vector<int> _c(n);  // новые классы эквивалентности
        int d = (1<<l)/2;
        int _cls = cnt = 0;  // новое количество классов
        
        for (int i = 0; i < n; i++) {
            int k = (p[i]-d+n)%n;
            a[c[k]].push_back(k);
        }
        
        for (int i = 0; i < cls; i++) {
            for (size_t j = 0; j < a[i].size(); j++) {
                // если суффикс начинает новый класс эквивалентности
                if (j == 0 || c[(a[i][j]+d)%n] != c[(a[i][j-1]+d)%n])
                    _cls++;
                _c[a[i][j]] = _cls-1;
                p[cnt++] = a[i][j];
            }
        }
        
        c = _c;
        cls = _cls;
    }
    
    return std::vector<int>(p.begin()+1, p.end());
}

std::vector<int> calc_lcp(std::vector<int> &val, std::vector<int> &c, std::vector<int> &p) {
    int n = val.size();
    int current_lcp = 0;
    std::vector<int> lcp(n);
    for (int i = 0; i < n; i++) {
        if (c[i] == n - 1)
            continue;
        int nxt = p[c[i] + 1];
        while (max(i, nxt) + current_lcp < n && val[i + current_lcp] == val[nxt + current_lcp])
            current_lcp++;
        lcp[c[i]] = current_lcp;
        current_lcp = max(0, current_lcp - 1);
    }
    return lcp;
}

int main() {
	std::cin.tie(nullptr)->sync_with_stdio(false);

	int n;
	std::cin >> n;
	std::vector<int> a(n + 1);
	auto calc = [&](int l, int r) -> int {
		std::vector q(a.begin() + l, a.begin() + r + 1);
		auto p = suffix_array(q);
		std::vector<int> c(p.size());
		for (int i = 0; i < p.size(); ++i) c[p[i]] = i;
		auto lcp = calc_lcp(q, c, p);
		int ans = q.size() * (q.size() + 1) / 2;
		for (auto i : lcp) ans -= i;
		return ans;
	};
	for (int i = 1; i <= n; ++i) {
		a[i] = i;
		int L = 0, R = i - 1;
		while (L != R) {
			int M = (L + R) / 2 + 1;
			std::cout << "? " << M << ' ' << i << std::endl;
			int res;
			std::cin >> res;
			if (calc(M, i) != res) L = M;
			else R = M - 1;
		}
		if (L != 0) a[i] = a[L];
	}
	std::cout << "!";
	for (int i = 1; i <= n; ++i) std::cout << ' ' << a[i];
	std::cout << std::endl;
}