import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.typecons;
 
void main ()
{
    int n, c;
    while (readf (" %s %s ", &n, &c) > 0)
    {
        auto a = new int [c];
        auto b = new int [c];
        auto d = new bool [c];
        enum {PARENT, LEFT, RIGHT}
        alias Edge = Tuple !(int, "v", int, "r");
        auto g = new Edge [] [n];
        foreach (i; 0..c)
        {
            auto t = readln ().split ();
            a[i] = t.front.to !(int) - 1;
            t.popFront ();
            b[i] = t.front.to !(int) - 1;
            t.popFront ();
            d[i] = (t.front == "LEFT");
            g[b[i]] ~= Edge (a[i], d[i] ? LEFT : RIGHT);
            g[a[i]] ~= Edge (b[i], PARENT);
        }
 
        auto z = new bool [n];
        auto parent = new int [n];
        auto left = new int [n];
        auto right = new int [n];
        immutable int NA = -1;
        parent[] = NA;
        left[] = NA;
        right[] = NA;
 
        int infix (int v, int last)
        {
            debug {writeln ("infix ", v, " ", last);}
            if (v == NA)
            {
                return last;
            }
            if (v < last || last == NA)
            {
                return NA;
            }
            last = v;
            last = infix (left[v], last);
            last = infix (right[v], last);
            return last;
        }
 
        bool check ()
        {
            debug {writeln ("check");}
            foreach (i; 0..c)
            {
                if (a[i] >= b[i])
                {
                    return false;
                }
                if (z[a[i]] && z[b[i]])
                {
                    int v = b[i];
                    while (v != NA)
                    {
                        int u = parent[v];
                        debug {writeln (v, " -> ", u);}
                        if (u == a[i])
                        {
                            if ((v == left[u]) !=
                                (d[i] == LEFT))
                            {
                                return false;
                            }
                            break;
                        }
                        v = u;
                    }
                    if (v == NA)
                    {
                        return false;
                    }
                }
            }
            debug {writeln (">", infix (0, 0));}
            return infix (0, 0) != NA;
        }
 
        bool place (int w, int v)
        {
            debug {writeln ("place ", w, " ", v);}
            if (w == NA)
            {
                return false;
            }
 
            parent[v] = w;
 
            left[v] = left[w];
            left[w] = v;
            if (check ())
            {
                return true;
            }
            left[w] = left[v];
            left[v] = NA;
 
            right[v] = left[w];
            left[w] = v;
            if (check ())
            {
                return true;
            }
            left[w] = right[v];
            right[v] = NA;
 
            left[v] = right[w];
            right[w] = v;
            if (check ())
            {
                return true;
            }
            right[w] = left[v];
            left[v] = NA;
 
            right[v] = right[w];
            right[w] = v;
            if (check ())
            {
                return true;
            }
            right[w] = right[v];
            right[v] = NA;
 
            parent[v] = NA;
 
            if (place (left[w], v))
            {
                return true;
            }
 
            if (place (right[w], v))
            {
                return true;
            }
 
            return false;
        }
 
        bool recur (int v)
        {
            debug {writeln ("recur ", v);}
            if (z[v])
            {
                return true;
            }
            z[v] = true;
            if (!place (0, v))
            {
                return false;
            }
            foreach (e; g[v])
            {
                if (!recur (e.v))
                {
                    return false;
                }
            }
            return true;
        }
 
        bool ok = true;
        z[0] = true;
        foreach (v; 1..n)
        {
            if (!z[v])
            {
                if (!recur (v))
                {
                    ok = false;
                    break;
                }
            }
        }
 
        if (!ok)
        {
            writeln ("IMPOSSIBLE");
            continue;
        }
 
        int [] ans;
 
        void prefix (int v)
        {
            debug {writeln ("prefix ", v);}
            if (v == NA)
            {
                return;
            }
            prefix (left[v]);
            ans ~= v + 1;
            prefix (right[v]);
        }
 
        prefix (0);
        writefln ("%(%s %)", ans);
    }
}