import java.io.*;

import java.lang.reflect.Array;
import java.util.*;
import java.lang.*;
import java.util.function.BinaryOperator;

public class Main {
    final static boolean debug = false;
    final static String fileName = "";
    final static boolean useFiles = false;

    public static void main(String[] args) throws FileNotFoundException {
        long start;
        if (debug)
            start = System.nanoTime();
        InputStream inputStream;
        OutputStream outputStream;
        if (useFiles) {
            inputStream = new FileInputStream(fileName + ".in");
            outputStream = new FileOutputStream(fileName + ".out");
        } else {
            inputStream = System.in;
            outputStream = System.out;
        }
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task(in, out);
        solver.solve();
        if(debug)
            out.println((System.nanoTime() - start) / 1e+9);
        out.close();
    }
}

class Item {
    long[] count;
    int size;

    Item(long[] count, int size) {
        this.count = count;
        this.size = size;
    }

    static Item combine(Item a, Item b) {
        if (a == null)
            return b;
        if (b == null)
            return a;
        long[] count = new long[5];
        int sz = a.size % 5;
        for (int i = 0; i < 5; i++) {
            count[i] = a.count[i] + b.count[(i - sz + 5) % 5];
        }
        return new Item(count, a.size + b.size);
    }
}

class SegmentTree {
    private Item[] t;
    private int n;

    SegmentTree(int n) {
        this.n = n;
        t = new Item[n << 2];
    }

    Item get(int l, int r) {
        if (l > n || r > n || 0 > l || 0 > r)
            throw new IllegalArgumentException("indices: (" + l + ", " + r + ") . Bounds: (0, "+ (n - 1));
        return get(0, 0, n - 1, l, r);
    }

    void set(int index, Item value) {
        if (0 > index || index > n)
            throw new IllegalArgumentException("index: " + index + ". Bounds: " + (n - 1));
        set(0, 0, n - 1, index, value);
    }

    private Item get(int v, int tl, int tr, int l, int r) {
        if (l > r)
            return null;
        if (tl == l && tr == r)
            return t[v];
        int tm = (tl + tr) >> 1;
        return Item.combine(get(2 * v + 1, tl, tm, l, Math.min(tm, r)),
                get(2 * v + 2, tm + 1, tr, Math.max(tm + 1, l), r));
    }

    private void set(int v, int tl, int tr, int index, Item value) {
        if (tr == tl)
            t[v] = value;
        else {
            int tm = (tl + tr) >> 1;
            if (index <= tm)
                set(2 * v + 1, tl, tm, index, value);
            else
                set(2 * v + 2, tm + 1, tr, index, value);
            t[v] = Item.combine(t[2 * v + 1], t[2 * v + 2]);
        }
    }
}

class Task {
    int[] order;
    int[] t;
    public void solve() {
        int n = in.nextInt();
        String[] types = new String[n];
        int[] parameters = new int[n];
        Arrays.fill(parameters, Integer.MAX_VALUE);
        for (int i = 0; i < n; i++) {
            types[i] = in.next();
            if (!types[i].equals("sum")) {
                parameters[i] = in.nextInt();
            }
        }
        int[] all = parameters.clone();
        Arrays.sort(all);
        order = new int[n];
        Arrays.fill(order, Integer.MAX_VALUE);
        order[0] = all[0];
        int top = 1;
        for (int i = 1; i < n; i++) {
            if (all[i] != all[i - 1])
                order[top++] = all[i];
        }
        SegmentTree tree = new SegmentTree(top);
        for (int i = 0; i < n; i++) {
            if (types[i].equals("sum")) {
                Item item = tree.get(0, top - 1);
                out.println(item == null ? 0 : item.count[2]);
//                for (int j = 0; j < 5; j++)
//                    out.print(count[j] + " ");
//                out.println();
            } else {
                int index = Arrays.binarySearch(order, parameters[i]);
//                out.println(parameters[i] + " " + index);
//                out.flush();
                if (types[i].equals("add")) {
                    long[] count = new long[5];
                    count[0] = parameters[i];
                    tree.set(index, new Item(count, 1));
                } else {
                    tree.set(index, new Item(new long[5], 0));
                }
            }
        }
    }

    private InputReader in;
    private PrintWriter out;

    Task(InputReader in, PrintWriter out) {
        this.in = in;
        this.out = out;
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public double nextDouble(){
        return Double.parseDouble(next());
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong(){
        return Long.parseLong(next());
    }

    public byte nextByte(){
        return Byte.parseByte(next());
    }
}
