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

public class Main {
	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;
	private Random rnd;
	

	
	Tree[] trees = new Tree[5];

	class Tree {
		long x, y, sum;
		Tree l, r;
		int size;
		
		Tree(long x, long y, Tree l, Tree r) {
			this.x = x;
			this.y = y;
			this.l = l;
			this.r = r;
			
			/* Recalc */
			this.size = 1;
			this.sum = this.x;
			
			if(l != null) {
				this.size += this.l.size;
				this.sum += this.l.sum;
			}
			
			if(r != null) {
				this.size += this.r.size;
				this.sum += this.r.sum;
			}
		}
	}
	
	class TreePair {
		Tree l, r;
		
		TreePair(Tree l, Tree r) {
			this.l = l;
			this.r = r;
		}
	}
	
	public Tree merge(Tree l, Tree r) {
		if(l == null) return r;
		if(r == null) return l;
		
		if(l.y > r.y) {
			return new Tree(l.x, l.y, l.l, merge(l.r, r));
		} else {
			return new Tree(r.x, r.y, merge(l, r.l), r.r);
		}
	}
	
	public TreePair splitByValue(Tree t, long x) {
		TreePair result = new TreePair(null, null);
		
		if(t == null) return result;
		
		if(x < t.x) {
			TreePair splitted = splitByValue(t.l, x);
			
			result.l = splitted.l;
			result.r = new Tree(t.x, t.y, splitted.r, t.r);
		} else {
			TreePair splitted = splitByValue(t.r, x);
			
			result.l = new Tree(t.x, t.y, t.l, splitted.l);
			result.r = splitted.r;
		}
		
		return result;
	}
	
	public Tree addValue(Tree t, long x) {
		Tree newTree = new Tree(x, rnd.nextLong(), null, null);
		
		if(t == null) return newTree;
		
		TreePair splitted = splitByValue(t, x);
		
		return merge(merge(splitted.l, newTree), splitted.r);
	}
	
	public int getPos(long x) {
		int res = 1;
		
		for(int i = 0; i < 5; i++) {
			TreePair splitted = splitByValue(trees[i], x);
			if(splitted.l != null) res += splitted.l.size;
		}
		
		return res;
	}
	
	public void swaps(long x) {
		TreePair last = splitByValue(trees[0], x);
		Tree firstLeft = last.l;
		
		for(int i = 1;  i < 5; i++) {
			TreePair cur = splitByValue(trees[i], x);
			
			trees[i] = merge(cur.l, last.r);
			
			last = cur;
		}
		
		trees[0] = merge(firstLeft, last.r);
	}
	
	public void swapsReverse(long x) {
		TreePair last = splitByValue(trees[4], x);
		Tree firstLeft = last.l;
		
		for(int i = 3;  i >= 0; i--) {
			TreePair cur = splitByValue(trees[i], x);
			
			trees[i] = merge(cur.l, last.r);
			
			last = cur;
		}
		
		trees[4] = merge(firstLeft, last.r);
	}
	
	public void printTree(Tree t, int level) {
		if(t == null) return;
		
		printTree(t.r, level + 1);
		for(int i = 0; i < level; i++) out.print("--");
		out.println(" " + t.x);
		printTree(t.l, level + 1);
	}
	
	public void removeValue(long x) {
		for(int i = 0; i < 5; i++) {
			TreePair firstSplit = splitByValue(trees[i], x);
			TreePair secondSplit = splitByValue(firstSplit.l, x - 1);
			
			trees[i] = merge(secondSplit.l, firstSplit.r);
		}
	}
	
	public long sum() {
		return (trees[2] == null) ? 0 : trees[2].sum;
	}

	
	public void solve() throws IOException {
		int n = nextInt();
		
		for(int i = 0; i < n; i++) {
			char action = nextToken().charAt(0);
			
			if(action == 'a') {
				long x = nextLong();
				int curTree = (getPos(x) - 1) % 5;
				
				swaps(x);
				
				trees[curTree] = addValue(trees[curTree], x);
			} else if(action == 's') {
				out.println(sum());
			} else if(action == 'd') {
				long x = nextLong();
				
				removeValue(x);
				
				swapsReverse(x);
			}
		}
	}
		
	public static void main(String[] args) {
		new Main().run();
	} 
	
	public void run() {
		try {
			//in = new BufferedReader(new FileReader("bigbadnumber.in"));
			//out = new PrintWriter(new FileWriter("bigbadnumber.out"));
			
			in = new BufferedReader(new InputStreamReader((System.in)));
			out = new PrintWriter(System.out);
			
			st = null;
			rnd = new Random();
			
			solve();
			
			out.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
	
	private String nextToken() throws IOException, NullPointerException {
		while(st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		
		return st.nextToken();
	}
	
	private int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	
	private long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	
	private double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

}