#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int N;

string mate(const string &s) {
  if (s.size() == 0) {
    return "";
  }
  int dep = 0;
  int cut = -1;
  for (int i = 0; i < (int)s.size(); ++i) {
    (s[i] == '-') ? --dep : ++dep;
    if (dep == 0) {
      cut = i;
      break;
    }
  }
  assert(~cut);
  const string sL = s.substr(1, cut - 1);
  const string sR = s.substr(cut + 1);
  string t;
  if (sL != sR) {
    t += '+';
    t += sR;
    t += '-';
    t += sL;
  } else {
    const string res = mate(sL);
    t += '+';
    t += res;
    t += '-';
    t += res;
  }
#ifdef LOCAL
cerr<<"[mate] "<<s<<" "<<t<<endl;
#endif
  return t;
}

string AS(const vector<string> &A) {
  const int X = A.size();
  const int Y = A[0].size();
  assert(X + Y == N + 1);
  vector<int> as(X, 0), bs(X - 1, 0);
  for (int x = 0; x < X; ++x) {
    for (int y = 0; y < Y; ++y) if (A[x][y] == '#') ++as[x];
  }
  for (int x = 0; x < X - 1; ++x) {
    for (int y = 0; y < Y; ++y) if (A[x][y] == '#' && A[x + 1][y] == '#') ++bs[x];
  }
  string S;
  S += string(as[0], '+');
  for (int x = 0; x < X - 1; ++x) {
    S += string(as[x] - bs[x] + 1, '-');
    S += string(as[x + 1] - bs[x] + 1, '+');
  }
  S += string(as[X - 1], '-');
#ifdef LOCAL
cerr<<"[AS] "<<A<<" "<<S<<endl;
#endif
  return S;
}

vector<string> SA(const string &S) {
  assert((int)S.size() == 2 * N);
  vector<int> ls;
  for (int i = 0, j = 0; i < 2 * N; i = j) {
    for (j = i; j < 2 * N && S[i] == S[j]; ++j) {}
    ls.push_back(j - i);
  }
  assert((int)ls.size() % 2 == 0);
  const int X = (int)ls.size() / 2;
  const int Y = N + 1 - X;
  vector<int> as(X, 0), bs(X - 1, 0);
  as[0] = ls[0];
  for (int x = 0; x < X - 1; ++x) {
    bs[x] = as[x] + 1 - ls[2 * x + 1];
    as[x + 1] = ls[2 * x + 2] + bs[x] - 1;
  }
  assert(as[X - 1] == ls.back());
  vector<string> A(X, string(Y, '.'));
  int l = Y, r = Y;
  for (int x = 0; x < X; ++x) {
    l = r - as[x];
    for (int y = l; y < r; ++y) A[x][y] = '#';
    if (x + 1 < X) {
      r = l + bs[x];
    }
  }
#ifdef LOCAL
cerr<<"[SA] "<<S<<" "<<A<<endl;
#endif
  return A;
}

string BS(const vector<int> &B) {
  string S;
  int y = 0;
  for (int i = 0; i < N; ++i) {
    for (; y < B[i]; ++y) S += '+';
    S += '-';
  }
#ifdef LOCAL
cerr<<"[BS] "<<B<<" "<<S<<endl;
#endif
  return S;
}

vector<int> SB(const string &S) {
  vector<int> B(N, -1);
  set<int> rems;
  for (int b = 1; b <= N; ++b) rems.insert(b);
  int cur = 0;
  int y = 0;
  for (int i = 0; i < N; ++i) {
    int yy = y;
    for (; S[cur] == '+'; ++cur) ++yy;
    assert(S[cur] == '-');
    ++cur;
    if (chmax(y, yy)) {
      B[i] = yy;
    } else {
      B[i] = *rems.begin();
    }
    auto it = rems.find(B[i]);
    assert(it != rems.end());
    rems.erase(it);
  }
#ifdef LOCAL
cerr<<"[SB] "<<S<<" "<<B<<endl;
#endif
  return B;
}

namespace CS_ {
vector<vector<int>> C;
vector<int> isss[110][110];
// u->v clockwise
string dfs(int i, int u, int v) {
// cerr<<"dfs "<<i<<" "<<u<<" "<<v<<endl;
  const int w = C[i][0] ^ C[i][1] ^ C[i][2] ^ u ^ v;
  string ret;
  ret += '+';
  if (isss[w][v].size() == 2) ret += dfs(isss[w][v][0] ^ isss[w][v][1] ^ i, w, v);
  ret += '-';
  if (isss[u][w].size() == 2) ret += dfs(isss[u][w][0] ^ isss[u][w][1] ^ i, u, w);
  return ret;
}
}  // CS_
string CS(const vector<vector<int>> &C) {
  using namespace CS_;
  CS_::C = C;
  for (int u = 1; u <= N + 2; ++u) for (int v = 1; v <= N + 2; ++v) {
    isss[u][v].clear();
  }
  for (int i = 0; i < N; ++i) {
    assert(C[i][0] < C[i][1]);
    assert(C[i][1] < C[i][2]);
    for (int j = 0; j < 3; ++j) for (int k = 0; k < 3; ++k) if (j != k) {
      isss[C[i][j]][C[i][k]].push_back(i);
    }
  }
  assert(isss[1][2].size() == 1);
  const string S = dfs(isss[1][2][0], 1, 2);
#ifdef LOCAL
cerr<<"[CS] "<<C<<" "<<S<<endl;
#endif
  return S;
}

namespace SC_ {
int id;
vector<vector<int>> tris;
int U;
vector<int> tr;
void dfs(const string &s, int u, int v) {
  if (s.size() == 0) {
    return;
  }
  int dep = 0;
  int cut = -1;
  for (int i = 0; i < (int)s.size(); ++i) {
    (s[i] == '-') ? --dep : ++dep;
    if (dep == 0) {
      cut = i;
      break;
    }
  }
  assert(~cut);
  const string sL = s.substr(1, cut - 1);
  const string sR = s.substr(cut + 1);
  const int w = ++id;
  tris.push_back(vector<int>{u, v, w});
  dfs(sL, w, v);
  tr[w] = ++U;
  dfs(sR, u, w);
}
}  // SC_
vector<vector<int>> SC(const string &S) {
  using namespace SC_;
  id = 0;
  tris.clear();
  U = 0;
  tr.assign(N + 2 + 1, -1);
  tr[++id] = ++U;
  tr[++id] = ++U;
  dfs(S, 1, 2);
  assert(id == N + 2);
  assert(U == N + 2);
  assert((int)tris.size() == N);
  vector<vector<int>> C(N, vector<int>(3, 0));
  for (int i = 0; i < N; ++i) {
    for (int j = 0; j < 3; ++j) {
      C[i][j] = tr[tris[i][j]];
    }
    sort(C[i].begin(), C[i].end());
  }
  sort(C.begin(), C.end());
#ifdef LOCAL
cerr<<"[SC] "<<S<<" "<<C<<endl;
#endif
  return C;
}

void outA(const vector<string> &A) {
  const int X = A.size();
  const int Y = A[0].size();
  puts("poly");
  printf("%d %d\n", X, Y);
  for (int x = 0; x < X; ++x) {
    puts(A[x].c_str());
  }
}
void outB(const vector<int> &B) {
  puts("perm");
  for (int i = 0; i < N; ++i) {
    if (i) printf(" ");
    printf("%d", B[i]);
  }
  puts("");
}
void outC(const vector<vector<int>> &C) {
  puts("triang");
  for (int i = 0; i < N; ++i) {
    printf("%d %d %d\n", C[i][0], C[i][1], C[i][2]);
  }
}

int main() {
  char typ[110], buf[110];
  int numCases;
  for (; ~scanf("%d%d", &N, &numCases); ) {
    printf("%d %d\n", N, numCases);
    for (; numCases--; ) {
      scanf("%s", typ);
      if (!strcmp(typ, "poly")) {
        int X, Y;
        scanf("%d%d", &X, &Y);
        vector<string> A(X);
        for (int x = 0; x < X; ++x) {
          scanf("%s", buf);
          A[x] = buf;
        }
        const string S = AS(A);
        const string T = mate(S);
        assert(S != T);
        if (S < T) {
          outB(SB(T));
        } else {
          outC(SC(T));
        }
      } else if (!strcmp(typ, "perm")) {
        vector<int> B(N);
        for (int i = 0; i < N; ++i) scanf("%d", &B[i]);
        const string S = BS(B);
        const string T = mate(S);
        if (S < T) {
          outC(SC(T));
        } else {
          outA(SA(T));
        }
      } else if (!strcmp(typ, "triang")) {
        vector<vector<int>> C(N, vector<int>(3));
        for (int i = 0; i < N; ++i) for (int j = 0; j < 3; ++j) scanf("%d", &C[i][j]);
        const string S = CS(C);
        const string T = mate(S);
        if (S < T) {
          outA(SA(T));
        } else {
          outB(SB(T));
        }
      }
    }
#ifdef LOCAL
cout<<string(80,'=')<<endl;
#else
break;
#endif
  }
  return 0;
}