#include <bits/stdc++.h>
using namespace std;
vector<int> a, b, l, r;
int n, c;
struct node {
  node() {
    left = -1;
    right = -1;
  }
  int value;
  int left;
  int right;
};
vector<node> nodes;
int tree_size(int index) {
  if (index == -1) return 0;
  int result = 1;
  result += tree_size(nodes[index].left);
  result += tree_size(nodes[index].right);
  return result;
}
void calculate_min_child(int value, int p, int& min_child) {
  min_child = min(min_child, p);
  for (int j = 0; j < c; ++j) {
    if (a[j] > value && p > a[j] && p <= b[j] && b[j] > value) {
      min_child = min(min_child, a[j]);
    }
  }
  if (min_child != p) calculate_min_child(value, min_child, min_child);
}
void calculate_max_child(int value, int p, int& max_child) {
  max_child = max(max_child, p);
  for (int j = 0; j < c; ++j) {
    if (a[j] > value && a[j] <= p && p < b[j] && b[j] > value) {
      max_child = max(max_child, b[j]);
    }
  }
  if (max_child != p) calculate_max_child(value, max_child, max_child);
}
void go(int root, int minimal, int maximal) {
  int index = root;
  int value = nodes[root].value;
  int max_child_left = 0;
  vector<int> left_children;
  for (int i = 0; i < c; ++i) {
    if (a[i] == nodes[root].value && l[i] && b[i] > value) {
      max_child_left = max(max_child_left, b[i]);
      left_children.push_back(b[i]);
    }
  }
  calculate_max_child(value, max_child_left, max_child_left);
  vector<int> right_children;
  int min_child_right = n + 1;
  for (int i = 0; i < c; ++i) {
    if (a[i] == nodes[root].value && r[i] && b[i] > value) {
      min_child_right = min(min_child_right, b[i]);
      right_children.push_back(b[i]);
    }
  }
  calculate_min_child(value, min_child_right, min_child_right);
  if (max_child_left != 0 && value + 1 >= minimal && value + 1 <= maximal) {
    node n;
    n.value = value + 1;
    nodes[index].left = nodes.size();
    nodes.push_back(n);
    go(nodes.size() - 1, minimal, min(maximal, min_child_right - 1));
  }
  int left_subtree = tree_size(nodes[root].left);
  if (value + left_subtree + 1 >= minimal &&
      value + 1 + left_subtree <= maximal) {
    node n;
    n.value = 1 + value + left_subtree;
    nodes[index].right = nodes.size();
    nodes.push_back(n);
    go(nodes.size() - 1, max(minimal, max_child_left + 1), maximal);
  }
}
bool validate_order(int index, int& order) {
  if (nodes[index].value != order) return false;
  if (nodes[index].left != -1 && !validate_order(nodes[index].left, ++order))
    return false;
  if (nodes[index].right != -1 && !validate_order(nodes[index].right, ++order))
    return false;
  return true;
}
bool contains(int index, int value) {
  if (index == -1) return false;
  if (nodes[index].value == value) return true;
  if (contains(nodes[index].left, value)) return true;
  if (contains(nodes[index].right, value)) return true;
  return false;
}
void answer(int index, vector<int>& result) {
  if (index == -1) return;
  answer(nodes[index].left, result);
  result.push_back(nodes[index].value);
  answer(nodes[index].right, result);
}
int main() {
  cin >> n >> c;
  for (int i = 0; i < c; ++i) {
    a.push_back(0);
    b.push_back(0);
    l.push_back(false);
    r.push_back(false);
    string word;
    cin >> a.back() >> b.back() >> word;
    if (word == "LEFT")
      l.back() = true;
    else if (word == "RIGHT")
      r.back() = true;
  }
  node root;
  root.value = 1;
  nodes.push_back(root);
  go(0, 1, n);
  int order = 1;
  if (!validate_order(0, order)) {
    cout << "IMPOSSIBLE\n";
    return 0;
  }
  for (int i = 0; i < c; ++i) {
    int index = -1;
    for (int j = 0; j < nodes.size(); ++j) {
      if (nodes[j].value == a[i]) index = j;
    }
    if (index == -1) {
      cout << "IMPOSSIBLE\n";
      return 0;
    }
    if (l[i]) {
      if (!contains(nodes[index].left, b[i])) {
        cout << "IMPOSSIBLE\n";
        return 0;
      }
    }
    if (r[i]) {
      if (!contains(nodes[index].right, b[i])) {
        cout << "IMPOSSIBLE\n";
        return 0;
      }
    }
  }
  vector<int> result;
  answer(0, result);
  for (int i = 0; i < result.size(); ++i) {
    cout << result[i] << " ";
  }
  return 0;
}
