#include <bits/stdc++.h>
struct fast_ios {
  fast_ios() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(10);
  };
} fast_ios_;
template <typename A, typename B>
bool chkmin(A &a, const B &b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <typename A, typename B>
bool chkmax(A &a, const B &b) {
  if (b > a) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &vec) {
  for (auto &x : vec) stream >> x;
  return stream;
}
template <typename T, typename U>
std::istream &operator>>(std::istream &in, std::pair<T, U> &p) {
  in >> p.first >> p.second;
  return in;
}
void scan() {}
template <class T, class... Args>
void scan(T &a, Args &...rest) {
  std::cin >> a;
  scan(rest...);
}
using ll = long long;
using vl = std::vector<ll>;
using vb = std::vector<bool>;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using pli = std::pair<ll, int>;
using pll = std::pair<ll, ll>;
template <typename T>
using vv = std::vector<std::vector<T>>;
template <typename T>
std::ostream &operator<<(std::ostream &stream, const std::vector<T> &vec) {
  if (!vec.empty()) {
    stream << vec[0];
    for (size_t i = 1; i != vec.size(); ++i) stream << ' ' << vec[i];
  }
  return stream;
}
template <typename T>
void print(const std::vector<T> &t) {
  std::cout << t << '\n';
}
template <typename T>
void print(const std::vector<std::vector<T>> &t) {
  for (const auto &row : t) {
    print(row);
  }
}
template <typename T>
void print(const T &t) {
  std::cout << t << ' ';
}
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
  print(t);
  print(rest...);
}
template <typename T>
void println(const T &t) {
  std::cout << t << '\n';
}
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
  print(t);
  println(rest...);
}
using namespace std;
class DYuiAndMahjongSet {
  static void SOLVE() {
    int n;
    scan(n);
    pll cur, pre;
    scan(cur);
    auto ask = [&](int i) {
      cout << "+ " << i << endl;
      pre = cur;
      scan(cur);
      return pii{cur.first - pre.first, cur.second - pre.second};
    };
    vi a(n + 1, -1);
    vi d(n + 1);
    for (int i = int(1); i <= int(n - 1); ++i) {
      auto diff = ask(i);
      if (diff.first > 0) {
        for (int j = int(2); j <= int(n); ++j) {
          if (j * (j - 1) / 2 == diff.first) {
            a[i] = j;
            break;
          }
        }
      }
      d[i] = diff.second;
    }
    auto diff = ask(1);
    if (a[1] == -1) {
      a[1] = diff.first;
    }
    int t = diff.second - d[1] - 1;
    if (a[2] == -1) {
      if (a[3] != -1) {
        a[2] = t - a[3];
      } else {
        if (t == 0) {
          a[2] = a[3] = 0;
        } else if (t == 2) {
          a[2] = a[3] = 1;
        } else {
          a[3] = d[2] > 0;
          a[2] = 1 - a[3];
        }
      }
    } else if (a[3] == -1) {
      a[3] = t - a[2];
    }
    for (int i = int(4); i <= int(n - 1); ++i) {
      if (a[i] == -1) {
        a[i] = d[i - 1] > (a[i - 2] + 1) * (a[i - 3] + 1);
      }
    }
    a[n] = (d[n - 1] - (a[n - 3] + 1) * (a[n - 2] + 1)) / (a[n - 2] + 1);
    cout << "!";
    for (int i = int(1); i <= int(n); ++i) {
      cout << " " << a[i];
    }
    cout << endl;
  }

 public:
  static void solve(std::istream &in, std::ostream &out) {
    auto cin_buff = std::cin.rdbuf(in.rdbuf());
    auto cerr_buff = std::cerr.rdbuf(std::cout.rdbuf(out.rdbuf()));
    SOLVE();
    std::cout.rdbuf(std::cerr.rdbuf(cerr_buff));
    std::cin.rdbuf(cin_buff);
  }
};
int main() {
  DYuiAndMahjongSet solver;
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  solver.solve(in, out);
  return 0;
}
