#include <bits/stdc++.h>
#include <vector>


struct fenvik {
    int n;
    std::vector<int> t;
    explicit fenvik(int n) : n(n), t(n) {}

    void add(int index, int val) {
        for (; index < n; index |= index + 1) {
            t[index] += val;
        }
    }

    int pref(int index) {
        int res = 0;
        for (;index >= 0; index = (index & (index + 1)) - 1) {
            res += t[index];
        }
        return res;
    }

    int sum(int l, int r) {
        return pref(r) - pref(l - 1);
    }
};


int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int max_ball, queries_amount;
    std::cin >> max_ball >> queries_amount;
    std::vector<int> open(max_ball, -1), close(max_ball, -1), pref_black{0},
            addX(max_ball), addY(max_ball), query(queries_amount);

    for (int index = 0; index < queries_amount; ++index) {
        std::string command;
        int number;
        std::cin >> command >> number;
        query[index] = --number;
        if (command[0] == 'a') {
            open[number] = index;
        } else {
            close[number] = index;
        }
    }

    fenvik tree(queries_amount);
    fenvik treeRed(queries_amount);

    for (int query_index = 0; query_index < queries_amount; ++query_index) {
        int number = query[query_index];

        if (open[number] == query_index) {
            if (close[number] != -1) {
                addY[number] += pref_black.back();
                tree.add(query_index, 1);
            } else {
                pref_black.push_back(pref_black.back() + 1);
            }
        } else if (close[number] == query_index) {
            addY[number] += tree.sum(0, open[number] - 1);
            addX[number] += treeRed.sum(0, open[number]);
            tree.add(open[number], -1);
            treeRed.add(query_index + 1, -1);
            treeRed.add(open[number], 1);
        }
    }

    int64_t ans = queries_amount;

    for (int index = 0; index < max_ball; ++index) {
        if (close[index] != -1) {
            ans += std::min(addX[index], addY[index]) * 2;
        }
    }

    std::cout << ans << '\n';
    return 0;
}