#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline istream& operator>>(istream& fin, pair<T1, T2>& pr) {
  fin >> pr.first >> pr.second;
  return fin;
}
template <class T0, class T1, class T2>
inline istream& operator>>(istream& fin, tuple<T0, T1, T2>& t) {
  fin >> get<0>(t) >> get<1>(t) >> get<2>(t);
  return fin;
}
template <class T>
inline istream& operator>>(istream& fin, vector<T>& a) {
  for (auto& u : a) fin >> u;
  return fin;
}
template <class T, size_t n>
inline istream& operator>>(istream& fin, array<T, n>& a) {
  for (auto& u : a) fin >> u;
  return fin;
}
typedef struct {
  size_t last_left;
  size_t first_right;
  size_t last_right;
} value_t;
size_t walk(const size_t root, size_t last, vector<value_t>& tree) {
  static const size_t nil = (size_t)-1;
  if (tree.size() == root) return root;
  auto& node = tree[root];
  size_t obs = root;
  if (node.last_left != 0) obs = walk(root + 1, node.last_left, tree);
  if (obs == nil || node.first_right < obs + 1) return nil;
  if (obs < last || 0 < node.last_right) {
    node.first_right = obs + 1;
    obs = walk(obs + 1, max(last, node.last_right), tree);
  }
  return obs;
}
void pre_order(const size_t root, const vector<value_t>& tree,
               vector<size_t>& path) {
  if (root == tree.size()) return;
  const auto& node = tree[root];
  if (node.last_left != 0) pre_order(root + 1, tree, path);
  path.push_back(root);
  if (root < node.first_right) pre_order(node.first_right, tree, path);
}
void d1513() {
  size_t n, m;
  cin >> n >> m;
  vector<value_t> tree(n + 1, {0, n + 1, 0});
  for (size_t i = 0; i < m; ++i) {
    size_t u, v;
    string str;
    cin >> u >> v >> str;
    if (v < u + 1 || n < v) {
      cout << "IMPOSSIBLE";
      return;
    }
    if (str == "LEFT")
      tree[u].last_left = max(tree[u].last_left, v);
    else {
      tree[u].first_right = min(tree[u].first_right, v);
      tree[u].last_right = max(tree[u].last_right, v);
    }
  }
  tree[1].last_right = n + 1;
  if (walk(1, 1, tree) == (size_t)-1) {
    cout << "IMPOSSIBLE";
    return;
  }
  vector<size_t> path;
  pre_order(1, tree, path);
  copy(begin(path), end(path), ostream_iterator<size_t>(cout, " "));
}
int main(const int argc, char* argv[]) {
  d1513();
  return EXIT_SUCCESS;
}
