#include <bits/stdc++.h>
using namespace std;
vector<int> leftSub[1000005];
vector<int> rightSub[1000005];
int leftSon[1000005], rightSon[1000005];
int maxVal[1000005], minVal[1000005];
int leftMax[1000005];
bool vis[1000005];
bool possible;
int n, c, a, b;
string d;
int cnt;
void findDfs(int u) {
  if (vis[u]) return;
  vis[u] = true;
  maxVal[u] = minVal[u] = u;
  int lmax = 0, rmax = 0;
  int lmin = n + 1, rmin = n + 1;
  int Lmax = 0, Rmin = n + 1;
  for (int i = 0; i < leftSub[u].size(); ++i) {
    int v = leftSub[u][i];
    lmax = max(lmax, v);
    lmin = min(lmin, v);
    findDfs(v);
    Lmax = max(Lmax, maxVal[v]);
    maxVal[u] = max(maxVal[u], maxVal[v]);
    minVal[u] = min(minVal[u], minVal[v]);
  }
  for (int i = 0; i < rightSub[u].size(); ++i) {
    int v = rightSub[u][i];
    rmax = max(rmax, v);
    rmin = min(rmin, v);
    findDfs(v);
    Rmin = min(Rmin, minVal[v]);
    maxVal[u] = max(maxVal[u], maxVal[v]);
    minVal[u] = min(minVal[u], minVal[v]);
  }
  if (lmin <= u || lmax >= rmin) {
    possible = false;
    return;
  }
  if (Lmax >= Rmin) {
    possible = false;
    return;
  }
  leftMax[u] = Lmax;
}
void findBoundary() {
  memset(vis, false, sizeof(vis));
  for (int i = n; i >= 1; --i) {
    if (!vis[i]) {
      findDfs(i);
    }
  }
}
void dfs(int l, int r) {
  ++cnt;
  int lmin = n + 1, lmax = 0;
  int rmin = n + 1, rmax = 0;
  if (leftSub[l].size()) {
    leftSon[l] = l + 1;
    for (int i = 0; i < leftSub[l].size(); ++i) {
      int v = leftSub[l][i];
      lmin = min(lmin, v);
      lmax = max(lmax, v);
    }
    if (lmin <= l) {
      possible = false;
      return;
    }
    dfs(l + 1, lmax);
  }
  if (rightSub[l].size()) {
    for (int i = 0; i < rightSub[l].size(); ++i) {
      int v = rightSub[l][i];
      rmin = min(rmin, v);
      rmax = max(rmax, v);
    }
    if (rmin <= cnt) {
      possible = false;
      return;
    }
    if (leftSub[l].size()) {
      rightSon[l] = cnt + 1;
      dfs(cnt + 1, max(r, rmax));
    } else {
      rightSon[l] = l + 1;
      dfs(l + 1, max(r, rmax));
    }
  } else {
    if (l == r) return;
    int leftBound = max(l, cnt);
    if (leftBound < r) {
      rightSon[l] = leftBound + 1;
      dfs(leftBound + 1, r);
    }
  }
}
void print(int u) {
  if (leftSon[u]) {
    print(leftSon[u]);
  }
  cout << u << " ";
  if (rightSon[u]) {
    print(rightSon[u]);
  }
}
void init() {
  memset(leftSon, 0, sizeof(leftSon));
  memset(rightSon, 0, sizeof(rightSon));
  possible = true;
  cnt = 0;
  for (int i = 1; i <= n; ++i) {
    leftMax[i] = 0;
  }
}
int main() {
  while (cin >> n >> c) {
    for (int i = 0; i < c; ++i) {
      cin >> a >> b >> d;
      if (d[0] == 'L') {
        leftSub[a].push_back(b);
      } else {
        rightSub[a].push_back(b);
      }
    }
    init();
    dfs(1, n);
    if (!possible) {
      puts("IMPOSSIBLE");
    } else {
      print(1);
      puts("");
    }
  }
  return 0;
}
