//
// Stvoreno ENERGom o 09.04.24. 14:23:51
//

#include<bits/stdc++.h>

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define MP make_pair
#define pb push_back
#define PB push_back
#define F first
#define fir first
#define S second
#define sec second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

#ifdef Energy
#define DEBUG for (int ____DEBUG=1;____DEBUG;____DEBUG=0)

template<class ...Ts>
auto &PRNT(Ts ...ts) { return ((cerr << ts << " "), ...); }

#define LOG(...) PRNT(#__VA_ARGS__" ::",__VA_ARGS__)<<endl
#else
#define DEBUG while(0)
#define LOG(...)
#endif

const int max_n = -1, inf = 1000111222;

struct rect {
    ll x, y, w, h;
    int cmd;
};

vector<rect> v;
ll W, H;

bool in_bound(rect r) {
    return r.x >= 0 && r.y >= 0 && r.x + r.w - 1 < W && r.y + r.h - 1 < H;
}

bool inter_x(rect a, rect b) {
    return !(a.x > b.x + b.w - 1 || b.x > a.x + a.w - 1);
}

bool inter_y(rect a, rect b) {
    return !(a.y > b.y + b.h - 1 || b.y > a.y + a.h - 1);
}

bool inter(rect a, rect b) {
    return inter_x(a, b) && inter_y(a, b);
}

bool belongs(rect r, int x, int y) {
    return x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h;
}

int get_by_pos(int x, int y) {
    for (int i = 0; i < v.size(); ++i) {
        if (belongs(v[i], x, y)) {
            return i;
        }
    }
    return -1;
}

bool try_open(rect r) {
    if (!in_bound(r)) {
        return 0;
    }
    for (rect x : v) {
        if (inter(r, x)) {
            return 0;
        }
    }
    v.PB(r);
    return true;
}

int dst_left(rect cur, rect to) {
    if (!inter_y(cur, to)) {
        return inf;
    }
    if (to.x > cur.x) {
        return inf;
    }
    return cur.x - (to.x + to.w);
}

int dst_top(rect cur, rect to) {
    if (!inter_x(cur, to)) {
        return inf;
    }
    if (to.y > cur.y) {
        return inf;
    }
    return cur.y - (to.y + to.h);
}

int move_left(int ind, int need) {
    set<int> cur;
    cur.insert(ind);
    int moved = 0;
    while(moved < need) {
        vector<pair<int, int>> nxt;
        ll min_x = inf;
        for (int i : cur) {
            min_x = min(min_x, v[i].x);
        }
        nxt.emplace_back(min_x, -1);
        for (int to = 0; to < v.size(); ++to) {
            if (cur.count(to)) {
                continue;
            }
            int min_dst = inf;
            for (int c : cur) {
                min_dst = min(min_dst, dst_left(v[c], v[to]));
            }
            if (min_dst == inf) continue;
            nxt.emplace_back(min_dst, to);
        }
        sort(nxt.begin(), nxt.end());
        int cur_move = nxt[0].F, attach = nxt[0].S;
        cur_move = min(cur_move, need - moved);
        for (int i : cur) {
            v[i].x -= cur_move;
        }
        moved += cur_move;
        if (moved == need) {
            return moved;
        }
        if (attach == -1) {
            return moved;
        }
        cur.insert(attach);
    }
    return moved;
}

int move_top(int ind, int need) {
    set<int> cur;
    cur.insert(ind);
    int moved = 0;
    while(moved < need) {
        vector<pair<int, int>> nxt;
        ll min_y = inf;
        for (int i : cur) {
            min_y = min(min_y, v[i].y);
        }
        nxt.emplace_back(min_y, -1);
        for (int to = 0; to < v.size(); ++to) {
            if (cur.count(to)) {
                continue;
            }
            int min_dst = inf;
            for (int c : cur) {
                min_dst = min(min_dst, dst_top(v[c], v[to]));
            }
            if (min_dst == inf) continue;
            nxt.emplace_back(min_dst, to);
        }
        sort(nxt.begin(), nxt.end());
        int cur_move = nxt[0].F, attach = nxt[0].S;
        cur_move = min(cur_move, need - moved);
        for (int i : cur) {
            v[i].y -= cur_move;
        }
        moved += cur_move;
        if (moved == need) {
            return moved;
        }
        if (attach == -1) {
            return moved;
        }
        cur.insert(attach);
    }
    return moved;
}

int move_right(int ind, int need) {
    for (auto& r : v) {
        r.x += (r.w - 1);
        r.x = W - r.x - 1;
    }
    int res = move_left(ind, need);
    for (auto& r : v) {
        r.x = W - r.x - 1;
        r.x -= (r.w - 1);
    }
    return res;
}

int move_bottom(int ind, int need) {
    for (auto& r : v) {
        r.y += (r.h - 1);
        r.y = H - r.y - 1;
    }
    int res = move_top(ind, need);
    for (auto& r : v) {
        r.y = H - r.y - 1;
        r.y -= (r.h - 1);
    }
    return res;
}

int move_rect(int ind, int dx, int dy) {
    if (dx == 0) {
        if (dy >= 0) {
            return move_bottom(ind, dy);
        } else {
            return move_top(ind, -dy);
        }
    } else {
        if (dx > 0) {
            return move_right(ind, dx);
        } else {
            return move_left(ind, -dx);
        }
    }
}

int main() {
//    freopen("input.txt","r",stdin);
//    freopen("output.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> W >> H;
    string cmd;
    int I = 0;
    while(cin >> cmd) {
        ++I;
        if (cmd == "OPEN") {
            rect r;
            cin >> r.x >> r.y >> r.w >> r.h;
            if (!try_open(r)) {
                cout << "Command " << I << ": " << "OPEN - window does not fit" << endl;
            } else {
                v.back().cmd = I;
            }
            continue;
        }
        if (cmd == "CLOSE") {
            ll x, y;
            cin >> x >> y;
            int ind = get_by_pos(x, y);
            if (ind == -1) {
                cout << "Command " << I << ": " << "CLOSE - no window at given position" << endl;
            } else {
                v.erase(v.begin() + ind);
            }
            continue;
        }
        if (cmd == "RESIZE") {
            int x, y, nw, nh;
            cin >> x >> y >> nw >> nh;
            int ind = get_by_pos(x, y);
            if (ind == -1) {
                cout << "Command " << I << ": " << "RESIZE - no window at given position" << endl;
                continue;
            }
            rect was = v[ind];
            v.erase(v.begin() + ind);
            rect newr = was;
            newr.w = nw;
            newr.h = nh;
            if (!try_open(newr)) {
                cout << "Command " << I << ": " << "RESIZE - window does not fit" << endl;
                v.push_back(was);
            }
            continue;
        }
        if (cmd == "MOVE") {
            int x, y, dx, dy;
            cin >> x >> y >> dx >> dy;
            int ind = get_by_pos(x, y);
            if (ind == -1) {
                cout << "Command " << I << ": " << "MOVE - no window at given position" << endl;
                continue;
            }
            int need_move = abs(dx) + abs(dy);
            int moved = move_rect(ind, dx, dy);
            if (moved < need_move) {
                cout << "Command " << I << ": " << "MOVE - moved " << moved << " instead of " << need_move << endl;
            }
        }
    }
    sort(v.begin(), v.end(), [](rect a, rect b) -> bool {return a.cmd < b.cmd;});
    cout << v.size() << " window(s):" << endl;
    for (auto r : v) {
        cout << r.x << ' ' << r.y << ' ' << r.w << ' ' << r.h << endl;
    }

    exit(0);
}