Problem: This is an interactive problem.

Yui is a girl who enjoys playing Mahjong.

<image>

She has a mysterious set which consists of tiles (this set can be empty). Each tile has an integer value between 1 and n, and at most n tiles in the set have the same value. So the set can contain at most n^2 tiles.

You want to figure out which values are on the tiles. But Yui is shy, she prefers to play a guessing game with you.

Let's call a set consisting of three tiles triplet if their values are the same. For example, \{2, 2, 2\} is a triplet, but \{2, 3, 3\} is not.

Let's call a set consisting of three tiles straight if their values are consecutive integers. For example, \{2, 3, 4\} is a straight, but \{1, 3, 5\} is not.

At first, Yui gives you the number of triplet subsets and straight subsets of the initial set respectively. After that, you can insert a tile with an integer value between 1 and n into the set at most n times. Every time you insert a tile, you will get the number of triplet subsets and straight subsets of the current set as well.

Note that two tiles with the same value are treated different. In other words, in the set \{1, 1, 2, 2, 3\} you can find 4 subsets \{1, 2, 3\}.

Try to guess the number of tiles in the initial set with value i for all integers i from 1 to n.

Input

The first line contains a single integer n (4 ≤ n ≤ 100).

The second line contains two integers which represent the number of triplet subsets and straight subsets of the initial set respectively.

Output

When you are ready to answer, print a single line of form "! a_1 a_2 … a_n" (0 ≤ a_i ≤ n), where a_i is equal to the number of tiles in the initial set with value i.

Interaction

To insert a tile, print a single line of form "+ x" (1 ≤ x ≤ n), where x is the value of the tile you insert. Then you should read two integers which represent the number of triplet subsets and straight subsets of the current set respectively.

After printing a line, do not forget to 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. 



You will get Wrong answer if you insert more than n tiles.

Hacks

To make a hack you should provide a test in such format:

The first line contains a single integer n (4 ≤ n ≤ 100).

The second line contains n integers a_1,a_2,…,a_n (0 ≤ a_i ≤ n) — a_i is equal to the number of tiles with value i in the set.

Example

Input


5
1 6
2 9
5 12
5 24
6 24


Output


+ 1
+ 1
+ 2
+ 5
! 2 1 3 0 2

Note

In the first test, the initial set of tiles is \{1, 1, 2, 3, 3, 3, 5, 5\}. It has only one triplet subset \{3, 3, 3\} and six straight subsets, all equal to \{1, 2, 3\}. After inserting a tile with value 1 the set of tiles will be \{1, 1, 1, 2, 3, 3, 3, 5, 5\} and will have two triplet subsets \{1, 1, 1\}, \{3, 3, 3\} and nine straight subsets, all equal to \{1, 2, 3\}.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &first, T2 second) {
  if (first > second) first = second;
}
template <typename T1, typename T2>
inline void chkmax(T1 &first, T2 second) {
  if (first < second) first = second;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
  _out << _p.first << ' ' << _p.second;
  return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
  _in >> _p.first >> _p.second;
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
  if (_v.empty()) {
    return _out;
  }
  _out << _v.front();
  for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
  for (auto &_i : _v) {
    _in >> _i;
  }
  return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
  if (_s.empty()) {
    return _out;
  }
  _out << *_s.begin();
  for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
    _out << ' ' << *_it;
  }
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
  if (_m.empty()) {
    return _out;
  }
  _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
    _out << ", (" << _it->first << ": " << _it->second << ')';
  }
  return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
  if (_m.empty()) {
    return _out;
  }
  _out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
  for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
    _out << ", (" << _it->first << ": " << _it->second << ')';
  }
  return _out;
}
const int N = 1e6 + 5;
int n;
vector<pair<int, int>> mem;
vector<int> cnt;
vector<int> t;
bool check(int id) {
  if (id >= n) return true;
  if (t[id] + 1 >= mem.size()) return true;
  int diff = mem[t[id] + 1].second - mem[t[id]].second;
  for (int i = -2; i <= 0; ++i) {
    if (id + i < 0) continue;
    if (id + i + 3 > cnt.size()) continue;
    int res = 1;
    for (int j = 0; j < 3; ++j) {
      int q = i + j + id;
      if (t[q] < t[id]) {
        res *= cnt[q] + 1;
      } else if (t[q] > t[id]) {
        res *= cnt[q];
      }
    }
    diff -= res;
  }
  return diff == 0;
}
vector<int> real_cnt;
void solve(int i) {
  if (i == -1) {
    for (int i = 0; i < 3; ++i) {
      if (!check(i)) {
        return;
      }
    }
    int all = 0;
    for (int i = 0; i + 3 <= n; ++i) {
      all += cnt[i] * cnt[i + 1] * cnt[i + 2];
    }
    if (all == mem[0].second) {
      cout << "! " << cnt << endl;
    }
    return;
  }
  if (!check(i + 3)) {
    return;
  }
  if (cnt[i] == 0) {
    ++cnt[i];
    solve(i - 1);
    --cnt[i];
  }
  solve(i - 1);
}
pair<int, int> count(vector<int> res = {}) {
  if (res.empty()) res = real_cnt;
  pair<int, int> ans = {0, 0};
  for (int i = 0; i < n; ++i) {
    ans.first += res[i] * (res[i] - 1) * (res[i] - 2) / 6;
    if (i + 2 < n) ans.second += res[i] * res[i + 1] * res[i + 2];
  }
  return ans;
}
void solving() {
  vector<vector<int>> possible, bin;
  for (int a = 0; a < 5 * 5 * 5 * 5; ++a) {
    possible.push_back({});
    int cur = a;
    for (int j = 0; j < 4; ++j) {
      possible.back().push_back(cur % 5);
      cur /= 5;
    }
  }
  for (int i = 0; i < possible.size(); ++i) {
    if (count(possible[i]) == mem[0]) {
      bin.push_back(possible[i]);
    }
  }
  swap(bin, possible);
  bin.clear();
  vector<int> f;
  for (int i = 0; i < 4; ++i) {
    int mx_val[4] = {0, 0, 0, 0};
    map<pair<int, int>, int> cur[4];
    for (auto v : possible) {
      for (int j = 0; j < 4; ++j) {
        v[j]++;
        cur[j][count(v)]++;
        v[j]--;
      }
    }
    for (int j = 0; j < 4; ++j) {
      for (auto [key, val] : cur[j]) {
        chkmax(mx_val[j], val);
      }
    }
    int id = min_element(mx_val, mx_val + 4) - mx_val;
    cout << "+ " << id + 1 << endl;
    f.push_back(id);
    cin >> mem[i + 1];
    sort(possible.begin(), possible.end());
    for (auto v : possible) {
      v[id]++;
      if (count(v) == mem[i + 1]) {
        bin.push_back(v);
      }
    }
    swap(bin, possible);
    bin.clear();
  }
  assert(possible.size() == 1);
  for (auto id : f) --possible[0][id];
  cout << "! " << possible[0] << endl;
}
int main() {
  ios::sync_with_stdio(0);
  srand(time(0));
  cin >> n;
  int tx = 1;
  while (tx--) {
    mem.resize(n + 1);
    cin >> mem[0];
    if (n == 4) {
      solving();
      continue;
    }
    cnt.resize(n);
    vector<int> order;
    t.resize(n);
    for (int i = 0; i < n; i += 2) {
      t[i] = order.size();
      order.push_back(i);
    }
    for (int i = 1; i < n; i += 2) {
      t[i] = order.size();
      order.push_back(i);
    }
    for (int i = 1; i <= n; ++i) {
      int id = order[i - 1] + 1;
      cout << "+ " << id << endl;
      cin >> mem[i];
      int v = mem[i].first - mem[i - 1].first;
      v *= 2;
      for (int j = 0;; ++j) {
        if (j * (j - 1) == v) {
          cnt[id - 1] = j;
          break;
        }
      }
    }
    solve(n - 1);
  }
}