import java.io.*;
import java.util.*;

public class MaartenScanner {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            new MaartenScanner().run(new Scanner(reader));
        }
    }

    public void run(Scanner sc) throws IOException {
        int n = sc.nextInt();
        long[] buyTree = new long[2 * n];
        long[] sellTree = new long[2 * n];
        PriorityQueue<long[]> buys = new PriorityQueue<>(Comparator.<long[]>comparingLong(a -> a[0]).thenComparingLong(a -> a[1]).thenComparingLong(a -> a[2]));
        PriorityQueue<long[]> sells = new PriorityQueue<>(Comparator.<long[]>comparingLong(a -> a[0]).thenComparingLong(a -> a[1]).thenComparingLong(a -> a[2]));
        List<int[]> orders = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            boolean buy = sc.next().equals("buy");
            boolean fok = sc.next().equals("fok");
            int price = sc.nextInt();
            int amount = sc.nextInt();
            orders.add(new int[]{buy ? 1 : 0, fok ? 1 : 0, price, amount});
        }

        Map<Integer, Integer> buyIndex = new HashMap<>();
        Map<Integer, Integer> sellIndex = new HashMap<>();

        List<int[]> sortedPrices = new ArrayList<>();
        for (int i = 0; i < orders.size(); i++) {
            sortedPrices.add(new int[]{i, orders.get(i)[2]});
        }
        sortedPrices.sort(Comparator.<int[]>comparingInt(a -> a[1]).thenComparingInt(a -> -a[0]));
        for (int i = 0; i < sortedPrices.size(); i++) {
            buyIndex.put(sortedPrices.get(i)[0], i);
        }
        sortedPrices.sort(Comparator.<int[]>comparingInt(a -> a[1]).thenComparingInt(a -> a[0]));
        for (int i = 0; i < sortedPrices.size(); i++) {
            sellIndex.put(sortedPrices.get(i)[0], i);
        }

        List<long[]> answers = new ArrayList<>();
        for (int i = 0; i < orders.size(); i++) {
            int[] order = orders.get(i);
            boolean buy = order[0] == 1;
            boolean fok = order[1] == 1;
            long p = order[2];
            long a = order[3];

            if (buy) {
                long remaining = SumSegTree.range_query(sellTree, 0, sellIndex.get(i));
                if (!fok || remaining >= a) {
                    while (remaining > 0 && !sells.isEmpty() && a > 0) {
                        long[] sellOrder = sells.poll();
                        long sellP = sellOrder[0];
                        long sellI = sellOrder[1];
                        long sellA = sellOrder[2];
                        long amount = Math.min(a, Math.min(sellA, remaining));
                        SumSegTree.update(sellTree, sellIndex.get((int) sellI), sellA - amount);
                        if (sellA - amount > 0) {
                            sells.offer(new long[]{sellP, sellI, sellA - amount});
                        }
                        remaining -= amount;
                        a -= amount;
                        answers.add(new long[]{i + 1, sellI + 1, amount});
                    }
                    if (a > 0) {
                        SumSegTree.update(buyTree, buyIndex.get(i), a);
                        buys.offer(new long[]{-p, i, a}); // Highest price first, so negate price
                    }
                }
            } else {
                long remaining = SumSegTree.range_query(buyTree, buyIndex.get(i), n);
                if (!fok || remaining >= a) {
                    while (remaining > 0 && !buys.isEmpty() && a > 0) {
                        long[] buyOrder = buys.poll();
                        long buyP = buyOrder[0];
                        long buyI = buyOrder[1];
                        long buyA = buyOrder[2];
                        long amount = Math.min(a, Math.min(buyA, remaining));
                        SumSegTree.update(buyTree, buyIndex.get((int) buyI), buyA - amount);
                        if (buyA - amount > 0) {
                            buys.offer(new long[]{buyP, buyI, buyA - amount});
                        }
                        remaining -= amount;
                        a -= amount;
                        answers.add(new long[]{buyI + 1, i + 1, amount});
                    }
                    if (a > 0) {
                        SumSegTree.update(sellTree, sellIndex.get(i), a);
                        sells.offer(new long[]{p, i, a}); // Lowest price first
                    }
                }
            }
        }

        System.out.println(answers.size());
        for (long[] answer : answers) {
            System.out.println(answer[1] + " " + answer[0] + " " + answer[2]);
        }
    }

    // Java Program to implement iterative segment tree.
    // Source: https://www.geeksforgeeks.org/iterative-segment-tree-range-minimum-query/
    // Adapted to use Sum instead of Min
    static class SumSegTree {

        static void update(long[] segtree, int pos, long value) {

            // change the index to leaf node first
            pos += segtree.length / 2;

            // update the value at the leaf node
            // at the exact index
            segtree[pos] = value;

            while (pos > 1) {

                // move up one level at a time in the tree
                pos >>= 1;

                // update the values in the nodes in
                // the next higher level
                segtree[pos] = segtree[2 * pos] + segtree[2 * pos + 1];
            }
        }

        static long range_query(long[] segtree, int left, int right) {

            /*
             * Basically the left and right indices will move
             * towards right and left respectively and with
             * every each next higher level and compute the
             * minimum at each height. */
            // change the index to leaf node first
            left += segtree.length / 2;
            right += segtree.length / 2;

            long ans = 0;

            while (left < right) {

                // if left index is odd
                if ((left & 1) == 1) {
                    ans += segtree[left];

                    // make left index even
                    left++;
                }

                // if right index is odd
                if ((right & 1) == 1) {

                    // make right index even
                    right--;

                    ans += segtree[right];
                }

                // move to the next higher level
                left >>= 1;
                right >>= 1;
            }
            return ans;
        }

    }

}