/*
    author:  Maksim1744
    created: 28.03.2024 11:46:49
*/

#include "bits/stdc++.h"

using namespace std;

using ll = long long;
using ld = long double;

#define mp   make_pair
#define pb   push_back
#define eb   emplace_back

#define sum(a)     ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a)    (*min_element((a).begin(), (a).end()))
#define maxe(a)    (*max_element((a).begin(), (a).end()))
#define mini(a)    ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a)    ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())

template<typename T>             vector<T>& operator--            (vector<T> &v){for (auto& i : v) --i;            return  v;}
template<typename T>             vector<T>& operator++            (vector<T> &v){for (auto& i : v) ++i;            return  v;}
template<typename T>             istream& operator>>(istream& is,  vector<T> &v){for (auto& i : v) is >> i;        return is;}
template<typename T>             ostream& operator<<(ostream& os,  vector<T>  v){for (auto& i : v) os << i << ' '; return os;}
template<typename T, typename U> pair<T,U>& operator--           (pair<T, U> &p){--p.first; --p.second;            return  p;}
template<typename T, typename U> pair<T,U>& operator++           (pair<T, U> &p){++p.first; ++p.second;            return  p;}
template<typename T, typename U> istream& operator>>(istream& is, pair<T, U> &p){is >> p.first >> p.second;        return is;}
template<typename T, typename U> ostream& operator<<(ostream& os, pair<T, U>  p){os << p.first << ' ' << p.second; return os;}
template<typename T, typename U> pair<T,U> operator-(pair<T,U> a, pair<T,U> b){return mp(a.first-b.first, a.second-b.second);}
template<typename T, typename U> pair<T,U> operator+(pair<T,U> a, pair<T,U> b){return mp(a.first+b.first, a.second+b.second);}
template<typename T, typename U> void umin(T& a, U b){if (a > b) a = b;}
template<typename T, typename U> void umax(T& a, U b){if (a < b) a = b;}

#ifdef HOME
#define SHOW_COLORS
#include "/mnt/c/Libs/tools/print.cpp"
#else
#define show(...) void(0)
#define debugf(fun)   fun
#define debugv(var)   var
#define mclock    void(0)
#define shows     void(0)
#define debug  if (false)
#define OSTREAM(...)    ;
#define OSTREAM0(...)   ;
#endif

// #define INTERACT

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 rng(4783682);
ll rnd (ll l, ll r) { return (ll)(rng() % (r - l + 1)) + l; }
ll rnd (ll r)       { return rng() % r; }
ll rnd ()           { return rng(); }
ld rndf()           { return (ld)rng() / (ld)ULLONG_MAX; }
ld rndf(ld l, ld r) { return rndf() * (r - l) + l; }

template<typename T>
struct fenwick {
    vector<T> tree;
    int n;
    int K;

    fenwick(int n = 0) : n(n) {
        tree.assign(n, 0);
        K = 0;
        while ((1 << K) <= n)
            ++K;
    }

    void add(int i, T k) {
        for (; i < n; i = (i | (i + 1)))
            tree[i] += k;
    }

    T ask(int r) {
        T res = 0;
        for (; r >= 0; r = (r & (r + 1)) - 1)
            res += tree[r];
        return res;
    }

    T ask(int l, int r) {
        if (l > r) return 0;
        return ask(r) - ask(l - 1);
    }

    // find first i such that sum[0..i] >= x
    int lower_bound(T x) {
        int cur = 0;
        T cur_sum = 0;
        for (int k = K - 1; k >= 0; --k) {
            int ind = cur | ((1 << k) - 1);
            if (ind >= n) continue;
            if (cur_sum + tree[ind] >= x) continue;
            cur_sum += tree[ind];
            cur |= (1 << k);
        }
        return cur;
    }
};

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);

    int n;
    #ifdef INTERACT
    n = 2000;
    #else
    cin >> n;
    #endif
    vector<int> invs_left(n);

    #ifdef INTERACT
    vector<int> p0(n);
    iota(p0.begin(), p0.end(), 1);
    shuffle(p0.begin(), p0.end(), rng);
    fenwick<int> tree(n);
    #endif

    map<pair<int, int>, int> mem;
    int que = 0;
    auto ask = [&](int i, int j) {
        assert(i <= j);
        if (i == j) return 0;
        if (mem.count({i, j})) return mem[{i, j}];
        ++que;
        int ans = 0;

        #ifdef INTERACT
        for (int k = i; k <= j; ++k) {
            ans += tree.ask(p0[k]-1, n-1);
            tree.add(p0[k]-1, 1);
        }
        for (int k = i; k <= j; ++k) {
            tree.add(p0[k]-1, -1);
        }
        #else
        cout << "? " << i + 1 << ' ' << j + 1 << endl;
        cin >> ans;
        #endif
        return mem[{i, j}] = ans;
    };

    vector<int> cur = {0};
    for (int i = 1; i < n; ++i) {
        shows;
        show(cur);
        auto cmp = [&](int i, int j) {
            int a = ask(i, j);
            int b = ask(i + 1, j);
            show(i, j, b, a, invs_left[i]);
            if ((b ^ a ^ invs_left[i]) % 2) {
                return false;
            } else {
                return true;
            }
        };

        int l = 0, r = cur.size();
        while (l != r) {
            int m = (l + r) / 2;
            if (cmp(cur[m], i)) {
                l = m + 1;
            } else {
                r = m;
            }
        }
        for (int j = l; j < cur.size(); ++j) {
            invs_left[cur[j]]++;
        }
        cur.insert(cur.begin() + l, i);
    }
    vector<int> p(n);
    for (int i = 0; i < n; ++i) {
        p[cur[i]] = i + 1;
    }
    #ifdef INTERACT
    if (p != p0) {
        cout << "ans: " << p0 << endl;
        cout << "out: " << p << endl;
        assert(false);
    }
    #endif
    cout << "! " << p << endl;
    #ifdef INTERACT
    cout << "que: " << que << endl;
    #endif

    return 0;
}