#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T SQR(T x) {
  return x * x;
}
template <class T>
inline string TOSTR(const T &x) {
  stringstream ss;
  ss << x;
  return ss.str();
}
template <class T>
void UPDATE_MIN(T &x, T y) {
  if (y < x) {
    x = y;
  }
}
template <class T>
void UPDATE_MAX(T &x, T y) {
  if (x < y) {
    x = y;
  }
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long p, long long m) {
  long long r = 1;
  while (p) {
    if (p & 1) r = r * a % m;
    p >>= 1;
    a = a * a % m;
  }
  return r;
}
const int MOD = 1000 * 1000 * 1000 + 7;
const double PI = 3.1415926535897932384626433832795l;
int min_left[(1000 * 1000 + 1)] = {};
int max_left[(1000 * 1000 + 1)] = {};
int min_right[(1000 * 1000 + 1)] = {};
int max_right[(1000 * 1000 + 1)] = {};
int tree_left[(1000 * 1000 + 1)] = {};
int tree_right[(1000 * 1000 + 1)] = {};
int sym_visit[(1000 * 1000 + 1)] = {};
int visited = 0;
int N, c;
int top;
int INF = (1000 * 1000 + 1);
void die() {
  cout << "IMPOSSIBLE\n";
  exit(0);
}
struct State {
  int node;
  int min;
  int max;
};
int main() {
  ios_base::sync_with_stdio(0);
  cin >> N >> c;
  for (int(i) = 0; (i) < (int)(N); (i)++) {
    min_left[i] = INF;
    min_right[i] = INF;
    max_left[i] = 0;
    max_right[i] = 0;
  }
  for (int(i) = 0; (i) < (int)(c); (i)++) {
    int a, b;
    string dir;
    cin >> a >> b >> dir;
    if (a >= b) die();
    if (dir == "LEFT") {
      UPDATE_MIN(min_left[a], b);
      UPDATE_MAX(max_left[a], b);
    } else {
      UPDATE_MIN(min_right[a], b);
      UPDATE_MAX(max_right[a], b);
    }
  }
  top = 1;
  stack<State> stack1;
  stack<State> stack2;
  stack1.push({top, 2, N});
  while (1) {
    while (!stack1.empty()) {
      State s = (stack1).top();
      (stack1).pop();
      ;
      if (max_left[s.node] > 0) {
        int new_min =
            (((s.min) < (min_left[s.node])) ? (s.min) : (min_left[s.node]));
        if (top >= new_min) die();
        State s_left;
        s_left.node = ++top;
        s_left.min = (((top + 1) > (new_min)) ? (top + 1) : (new_min));
        s_left.max = max_left[s.node];
        tree_left[s.node] = s_left.node;
        stack1.push(s_left);
      }
      stack2.push(s);
    }
    if (stack2.empty()) break;
    {
      State s = (stack2).top();
      (stack2).pop();
      ;
      sym_visit[visited++] = s.node;
      int new_max = s.max;
      int new_min = top + 1;
      if (max_right[s.node] > 0) {
        if (top >= min_right[s.node]) die();
        new_max = (((new_max) > (max_right[s.node])) ? (new_max)
                                                     : (max_right[s.node]));
      }
      if (top < new_max) {
        State s_right;
        s_right.node = ++top;
        s_right.min = (((top + 1) > (new_min)) ? (top + 1) : (new_min));
        s_right.max = new_max;
        tree_right[s.node] = s_right.node;
        stack1.push(s_right);
      }
    }
  }
  for (int(i) = 0; (i) < (int)(visited); (i)++) {
    cout << sym_visit[i] << " \n"[i == visited - 1];
  }
  return 0;
}
