#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
  char ch;
  x = 0;
  bool fl = false;
  while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
  for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
    ;
  (fl == true) && (x = -x);
}
template <class T>
inline void output(T x) {
  if (x / 10) output(x / 10);
  putchar(x % 10 + '0');
}
template <class T>
inline void ot(T x) {
  if (x < 0) putchar('-'), x = -x;
  output(x);
  putchar(' ');
}
template <class T>
inline void prt(T a[], int st, int nd) {
  for (register int i = st; i <= nd; ++i) ot(a[i]);
  putchar('\n');
}
namespace Modulo {
const int mod = 998244353;
int ad(int x, int y) { return (x + y) >= mod ? x + y - mod : x + y; }
void inc(int &x, int y) { x = ad(x, y); }
int mul(int x, int y) { return (long long)x * y % mod; }
void inc2(int &x, int y) { x = mul(x, y); }
int qm(int x, int y = mod - 2) {
  int ret = 1;
  while (y) {
    if (y & 1) ret = mul(x, ret);
    x = mul(x, x);
    y >>= 1;
  }
  return ret;
}
}  // namespace Modulo
namespace Miracle {
const int N = 2005;
int n;
char s[233];
int fa[N], ch[N][2], has[N][2];
int tot;
int ask(int a, int b, int c) {
  printf("%d %d %d\n", a, b, c);
  fflush(stdout);
  scanf("%s", s + 1);
  return (s[1] - 'X');
}
bool vis[N];
int rt, sz[N];
int nowsz;
void dfs(int x, int od) {
  if (!x) return;
  sz[x] = 1;
  int mx = 0, now;
  if (!vis[fa[x]] && fa[x] != od)
    dfs(fa[x], x), mx = max(mx, sz[fa[x]]), sz[x] += sz[fa[x]];
  if (!vis[ch[x][0]] && ch[x][0] != od)
    dfs(ch[x][0], x), mx = max(mx, sz[ch[x][0]]), sz[x] += sz[ch[x][0]];
  if (!vis[ch[x][1]] && ch[x][1] != od)
    dfs(ch[x][1], x), mx = max(mx, sz[ch[x][1]]), sz[x] += sz[ch[x][1]];
  if ((ch[x][0] || ch[x][1]) && (max(mx, nowsz - sz[x]) <= nowsz / 2)) rt = x;
}
void dfs2(int x, int od) {
  if (!x) return;
  sz[x] = 1;
  if (!vis[fa[x]] && fa[x] != od) dfs2(fa[x], x), sz[x] += sz[fa[x]];
  if (!vis[ch[x][0]] && ch[x][0] != od)
    dfs2(ch[x][0], x), sz[x] += sz[ch[x][0]];
  if (!vis[ch[x][1]] && ch[x][1] != od)
    dfs2(ch[x][1], x), sz[x] += sz[ch[x][1]];
}
void fin(int x, int id) {
  if (!ch[x][0] && !ch[x][1]) {
    ++tot;
    int d = ch[fa[x]][1] == x;
    ch[tot][0] = x;
    ch[tot][1] = id;
    fa[tot] = fa[x];
    ch[fa[x]][d] = tot;
    fa[x] = tot;
    fa[id] = tot;
    has[tot][0] = x;
    has[tot][1] = id;
    return;
  }
  rt = 0;
  dfs(x, 0);
  x = rt;
  dfs2(rt, 0);
  int bc = ask(has[rt][0], has[rt][1], id);
  vis[rt] = 1;
  if (bc == 0) {
    if (fa[x]) {
      if (vis[fa[x]]) {
        int y = fa[x];
        int d = ch[y][1] == x;
        ch[y][d] = ++tot;
        fa[tot] = y;
        ch[tot][d] = x;
        fa[x] = tot;
        ch[tot][d ^ 1] = id;
        fa[id] = tot;
        has[tot][d] = has[x][0];
        has[tot][d ^ 1] = id;
      } else {
        nowsz = sz[fa[x]];
        fin(fa[x], id);
      }
    } else {
      fa[x] = ++tot;
      ch[tot][0] = x;
      ch[tot][1] = id;
      has[tot][0] = has[x][0];
      has[tot][1] = id;
      fa[id] = tot;
    }
  } else {
    int p;
    if (bc == 1)
      p = 1;
    else
      p = 0;
    if (ch[x][p]) {
      int z = ch[x][p];
      if (vis[z]) {
        ++tot;
        ch[x][p] = tot;
        fa[tot] = x;
        ch[tot][p] = z;
        fa[z] = tot;
        ch[tot][p ^ 1] = id;
        fa[id] = tot;
        has[tot][p ^ 1] = id;
        has[tot][p] = has[z][0];
      } else {
        nowsz = sz[z];
        fin(z, id);
      }
    } else {
      assert(-1 > 0);
    }
  }
}
int main() {
  rd(n);
  tot = n;
  ++tot;
  has[tot][0] = ch[tot][0] = 1;
  fa[1] = tot;
  has[tot][1] = ch[tot][1] = 2;
  fa[2] = tot;
  for (register int i = 3; i <= n; ++i) {
    memset(vis, 0, sizeof vis);
    memset(sz, 0, sizeof sz);
    nowsz = 2 * (i - 1) - 1;
    fin(tot, i);
  }
  printf("-1\n");
  for (register int i = 1; i <= tot; ++i) {
    if (!fa[i]) fa[i] = -1;
    ot(fa[i]);
  }
  return 0;
}
}  // namespace Miracle
signed main() {
  Miracle::main();
  return 0;
}
