func_code_string: #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;   }   