#include <bits/stdc++.h>
using namespace std;
template <typename T>
void debug_out(T t) {
  cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> u) {
  cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> t) {
  int sz = t.size();
  for (int i = 0; i < sz; i++) {
    debug_out(t[i]);
    if (i != sz - 1) cerr << ", ";
  }
}
template <typename T>
void debug_out(vector<vector<T>> t) {
  int sz = t.size();
  for (int i = 0; i < sz; i++) {
    debug_out(t[i]);
    if (i != sz - 1) cerr << endl;
  }
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  debug_out(H);
  cerr << " ";
  debug_out(T...);
}
template <typename T>
void debug_out(set<T> a) {
  vector<T> _a;
  for (T t : a) _a.push_back(t);
  debug_out(_a);
}
int n;
int main() {
  cin >> n;
  int triple;
  int straight;
  cin >> triple >> straight;
  vector<int> res(n, -1);
  vector<int> cur(n, -1);
  auto add = [&](int x) {
    cout << "+ " << x + 1 << endl;
    int a, b;
    cin >> a >> b;
    return make_pair(a, b);
  };
  auto update = [&](pair<int, int> foo) {
    triple = foo.first;
    straight = foo.second;
  };
  update(add(2));
  pair<int, int> mes = add(3);
  int ans = mes.second - straight;
  pair<int, int> bonus = add(1);
  int ps = bonus.second - mes.second;
  pair<int, int> foo = add(3);
  if (foo.first == bonus.first) {
    res[3] = 0;
    cur[3] = 2;
  } else {
    cur[3] = 0;
    while (cur[3] * (cur[3] - 1) / 2 < foo.first - bonus.first) cur[3]++;
    cur[3]++;
    res[3] = cur[3] - 2;
  }
  res[2] = foo.second - mes.second - bonus.second + straight - 1;
  cur[2] = res[2] + 1;
  res[0] = ps / (res[2] + 1) - res[3] - 1;
  cur[0] = res[0];
  update(foo);
  if (n == 4) {
    res[1] = ans / (res[2] + 1);
    cur[1] = res[1] + 1;
  } else if (n == 5) {
    foo = add(1);
    cur[1] = 0;
    while (cur[1] * (cur[1] - 1) / 2 < foo.first - triple) cur[1]++;
    cur[1]++;
    if (cur[1] == 1) cur[1]++;
    res[1] = cur[1] - 2;
    res[4] = (ans - (res[2] + 1) * res[1]) / (res[2] + 1);
    cur[4] = res[4];
    update(foo);
  } else {
    for (int i = 4; i + 3 < n; i += 4) {
      foo = add(i + 3);
      bonus = add(i + 1);
      mes = add(i + 3);
      res[i + 2] = cur[i + 2] =
          mes.second - foo.second - bonus.second + straight;
      cur[i + 3] = 0;
      while (cur[i + 3] * (cur[i + 3] - 1) / 2 < mes.first - bonus.first)
        cur[i + 3]++;
      cur[i + 3]++;
      if (cur[i + 3] == 1) cur[i + 3]++;
      res[i + 3] = cur[i + 3] - 2;
      cur[i] = res[i] =
          (bonus.second - foo.second - res[i + 2] * (res[i + 3] + 1)) /
          (res[i + 2] + cur[i - 1]);
      foo = add(i + 1);
      cur[i + 1] = 0;
      while (cur[i + 1] * (cur[i + 1] - 1) / 2 < foo.first - mes.first)
        cur[i + 1]++;
      cur[i + 1]++;
      cur[i + 1] = max(cur[i + 1], 2);
      res[i + 1] = cur[i + 1] - 2;
      update(foo);
    }
    if (n % 4 == 1) {
      foo = add(n - 3);
      cur[n - 3]++;
      int base = foo.second - straight - cur[n - 4] * cur[n - 5] -
                 cur[n - 4] * cur[n - 2];
      res[n - 1] = cur[n - 1] = base / cur[n - 2];
      update(foo);
    }
    if (n % 4 == 2) {
      foo = add(n - 2);
      int base = foo.second - straight - cur[n - 4] * cur[n - 3];
      res[n - 1] = cur[n - 1] = base / cur[n - 3];
      update(foo);
      foo = add(n - 1);
      cur[n - 1]++;
      base = foo.second - straight;
      cur[n - 2] = base / cur[n - 3];
      res[n - 2] = cur[n - 2] - 1;
      update(foo);
    }
    if (n % 4 == 3) {
      foo = add(n - 3);
      bonus = add(n - 2);
      mes = add(n - 3);
      cur[n - 3] = 0;
      while (cur[n - 3] * (cur[n - 3] - 1) / 2 < mes.first - bonus.first)
        cur[n - 3]++;
      cur[n - 3]++;
      if (cur[n - 3] == 1) cur[n - 3]++;
      res[n - 3] = cur[n - 3] - 2;
      int base = bonus.second - foo.second - cur[n - 4] * (res[n - 3] + 1);
      res[n - 1] = cur[n - 1] = base / (res[n - 3] + 1);
      base = mes.second - bonus.second - cur[n - 4] * cur[n - 5];
      cur[n - 2] = base / (cur[n - 4] + cur[n - 1]);
      res[n - 2] = cur[n - 2] - 1;
      update(mes);
    }
    res[1] = (ans - res[4] * res[5] - (res[2] + 1) * res[4]) / (res[2] + 1);
    cur[1] = res[1] + 1;
  }
  cout << "! ";
  for (int i : res) cout << i << " ";
  cout << endl;
  return 0;
}
