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

public class D implements Runnable {
	private final boolean useStandardIO = true;
	private final String inFile = ".in";
	private final String outFile = ".out";

	class Command {
		String name;
		int x;
	}

	List<Long> brute(List<Command> commands) {
		SortedSet<Long> h = new TreeSet<Long>();
		List<Long> res = new ArrayList<Long>();
		for (Command c : commands) {
			if (c.name.equals("sum")) {
				long rr = 0;
				int i = 0;
				for (long r : h) {
					if ((++i) % 5 == 3)
						rr += r;
				}
				res.add(rr);
			} else if (c.name.equals("add")) {
				h.add((long) c.x);
			} else {
				h.remove((long) c.x);
			}
		}
		return res;
	}

	List<Long> solve(List<Command> commands) throws Exception {
		List<Integer> all = new ArrayList<Integer>();
		for (Command c : commands) {
			if (c.name.equals("sum")) {
			} else {
				all.add(c.x);
			}
		}
		Collections.sort(all);
		Map<Integer, Integer> hm = new HashMap<Integer, Integer>();
		int z = 0;
		for (int i = 0; i < all.size(); ++i)
			if (i == 0 || all.get(i) != all.get(i - 1)) {
				hm.put(all.get(i), z++);
			}
		Node root = createTree(0, hm.size());
		List<Long> res = new ArrayList<Long>();
		HashSet<Integer> hhh = new HashSet<Integer>();
		for (Command c : commands) {
			if (c.name.equals("sum")) {
				res.add(getSum(root));
			} else if (c.name.equals("add")) {
				if (hhh.contains(c.x))
					throw new Exception();
				hhh.add(c.x);
				add(root, hm.get(c.x), c.x);
			} else if (c.name.equals("del")) {
				if (!hhh.contains(c.x))
					throw new Exception();
				hhh.remove(c.x);
				delete(root, hm.get(c.x), c.x);
			} else
				throw new Exception();
		}
		return res;
	}

	private void solve() throws Exception {
		/*
		 * List<Command> cc = new ArrayList<Command>();
		 * 
		 * Random r = new Random(123); for (int i = 1; i <= 10000; ++i) { int k
		 * = r.nextInt(100); Command c = new Command(); c.name = "add " + i +
		 * 1000000; cc.add(c);
		 * 
		 * c = new Command(); c.name = "sum"; cc.add(c);
		 * 
		 * if (i % 4 == 0) { c = new Command(); c.name = "del " + i + 1000000;
		 * cc.add(c); } }
		 * 
		 * List<Long> my = solve(cc); List<Long> br = brute(cc);
		 * 
		 * if (my.size() != br.size()) { throw new Exception(); }
		 * 
		 * for (int i = 0; i < my.size(); ++i) if (my.get(i) != br.get(i)) throw
		 * new Exception();
		 */

		int n = nextInt();
		List<Command> cmds = new ArrayList<Command>();
		for (int i = 0; i < n; ++i) {
			String cmd = nextToken();
			Command c = new Command();
			if (cmd.equals("sum")) {
			} else if (cmd.equals("add") || cmd.equals("del")) {
				long x = nextLong();
				if (x < 1 || x > 1000000000)
					throw new Exception();
				c.x = (int) x;
			} else
				throw new Exception();
			c.name = cmd;
			cmds.add(c);
		}
		for (long r : solve(cmds))
			writer.println(r);

	}

	void add(Node t, int u, long real) {
		int mid = (t.L + t.R) / 2;
		if (t.L == t.R) {
			t.sum[0] = real;
			t.cnt = 1;
		} else {
			if (u <= mid) {
				add(t.l, u, real);
			} else {
				add(t.r, u, real);
			}
			t.cnt++;
			for (int i = 0; i < 5; ++i)
				t.sum[i] = t.l.sum[i] + t.r.sum[((i - t.l.cnt) % 5 + 5) % 5];
		}
	}

	void delete(Node t, int u, long real) {
		int mid = (t.L + t.R) / 2;
		if (t.L == t.R) {
			t.sum[0] = 0;
			t.cnt = 0;
		} else {
			if (u <= mid) {
				delete(t.l, u, real);
			} else {
				delete(t.r, u, real);
			}
			t.cnt--;
			for (int i = 0; i < 5; ++i)
				t.sum[i] = t.l.sum[i] + t.r.sum[((i - t.l.cnt) % 5 + 5) % 5];
		}
	}

	long getSum(Node t) {
		return t.sum[2];
	}

	Node createTree(int L, int R) {
		Node t = new Node();
		t.sum = new long[5];
		t.cnt = 0;
		t.L = L;
		t.R = R;
		if (L < R) {
			int mid = (L + R) / 2;
			t.l = createTree(L, mid);
			t.r = createTree(mid + 1, R);
		}
		return t;
	}

	class Node {
		Node l, r;
		long[] sum;
		int cnt, L, R;
	}

	public static void main(String[] args) {
		new Thread(null, new D(), "", 64 * 1024 * 1024).run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() {
		try {
			try {
				Locale.setDefault(Locale.US);
			} catch (Exception e) {
			}
			if (useStandardIO) {
				reader = new BufferedReader(new InputStreamReader(System.in));
				writer = new PrintWriter(System.out);
			} else {
				reader = new BufferedReader(new FileReader(inFile));
				writer = new PrintWriter(new FileWriter(outFile));
			}
			tokenizer = null;
			solve();
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	BigInteger nextBigInteger() throws IOException {
		return new BigInteger(nextToken());
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}