import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.InputStream;
import java.lang.*;

public class Source {
	public static void main(String[] args) {
		InputReader in = new InputReader(System.in);
		PrintWriter ou = new PrintWriter(System.out);		
		MainCode obj = new MainCode();
		obj.Solve(in, ou);
		ou.close();
	}
	
}

class MainCode {
	private int n, q;
	private int[] k, a, fa;
	private int[] lazy, size;
	private long[][] tree;
	
	public void Solve(InputReader inp, PrintWriter out) {
		q = inp.nextInt();
		k = new int[q];
		a = new int[q];
		for (int i = 0; i < q; ++i) {
			String S = inp.next();
			if (S.charAt(0) == 'a') {
				k[i] = 0;
				a[i] = inp.nextInt();
			}
			else if (S.charAt(0) == 'd') {
				k[i] = 1;
				a[i] = inp.nextInt();
			}
			else k[i] = 2;
		}
		Compress();
		
		tree = new long[2 * n][5];
		lazy = new int[n];
		size = new int[2 * n];
		for (int i = 0; i < q; ++i) {
			if (k[i] == 0) Update(fa[i], n - 1, a[i]); else
			if (k[i] == 1) Update(fa[i], n - 1, -a[i]); else
				out.println(Query());
		}
	}
	
	private void Compress() {
		Integer[] p = new Integer[q];
		for (int i = 0; i < q; ++i) p[i] = i;
		Arrays.sort(p, new Comparator<Integer>() {
			public int compare(Integer x, Integer y) {
				return a[x] - a[y];
			}
		});
		
		fa = new int[q]; fa[p[0]] = (a[p[0]] == 0) ? -1 : 0;
		for (int i = 1; i < q; ++i) {
			fa[p[i]] = fa[p[i - 1]];
			if (a[p[i]] != a[p[i - 1]]) fa[p[i]]++;
		}
		n = fa[p[q - 1]] + 1;
	}
	
	void Rotate(int k, int v) {
		long[] temp = new long[5];
		for (int i = 0; i < 5; ++i) temp[i] = tree[k][(i + 5 - v) % 5];
		for (int i = 0; i < 5; ++i) tree[k][i] = temp[i];
	}
	
	void Apply(int k, int v) {
		if (k < n) lazy[k] = (lazy[k] + v) % 5;
		Rotate(k, v);
	}
	
	void PushUp(int k) {
		while (k > 1) {
			k >>= 1;
			size[k] = size[k << 1] + size[k << 1 | 1];
			for (int i = 0; i < 5; ++i) tree[k][i] = tree[k << 1][i] + tree[k << 1 | 1][i];
			Rotate(k, lazy[k]);
		}
	}
	
	void PushDown(int k) {
		for (int i = 20; i > 0; --i) {
			int r = k >> i;
			if (lazy[r] != 0) {
				Apply(r << 1 | 0, lazy[r]);
				Apply(r << 1 | 1, lazy[r]);
				lazy[r] = 0;
			}
		}
	}
	
	void Add(int i, int v) {
		size[i + n] += (v > 0) ? 1 : -1;
		tree[i + n][Count(0, i - 1) % 5] += v;
		PushUp(i + n);
	}
	
	void Update(int l, int r, int v) {
		l += n; r += n;
		int lCopy = l;
		int rCopy = r;
		PushDown(l);
		PushDown(r);
		if (v < 0) Add(lCopy - n, v);
		int k = (v > 0) ? 1 : 4;
		for (; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
			if ((l & 1) == 1) Apply(l++, k);
			if ((r & 1) == 0) Apply(r--, k);
		}
		PushUp(lCopy);
		PushUp(rCopy);
		if (v > 0) {
			PushDown(lCopy);
			PushDown(rCopy);
			Add(lCopy - n, v);
		}
	}
	
	int Count(int l, int r) {
		int res = 0;
		for (l += n, r += n; l <= r; l = (l + 1) >> 1, r = (r - 1) >> 1) {
			if ((l & 1) == 1) res += size[l++];
			if ((r & 1) == 0) res += size[r--];
		}
		return res;
	}
	
	long Query() {
		return (n == 0) ? 0 : tree[1][2];
	}
	
}

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 int nextInt() {
        return Integer.parseInt(next());
    }
    
    public long nextLong() {
    	return Long.parseLong(next());
    }
    
    public double nextDouble() {
    	return Double.parseDouble(next());
    }

}