diff --git a/gdb-port/parser.py b/gdb-port/parser.py
index ffcaec886c3973755c11ad50c76c72446acc3362..766210dd62d76115cb51c59bef8e957786b9ebf8 100644
--- a/gdb-port/parser.py
+++ b/gdb-port/parser.py
@@ -176,7 +176,6 @@ class ParserStack:
 			#print("adding mem use: parser:", str(parser_obj), "arena:", hex(int(self.arena)), "bytes:", allocated_bytes) # DEBUG
 			#print("adding mem use (alternate): parser:", str(parser_obj), "arena:", hex(int(self.arena)), "bytes:", allocs) # DEBUG
 			#parser_obj.add_mem_use(int(self.arena), allocs)
-			# TODO: allocations can be attributed to individual h_do_parse(parser) calls, thus the same per-parser per-arena stats tracking can be done
 
 		return self.p_stack.pop()
 
@@ -233,67 +232,6 @@ class ParserStack:
 	def depth(self):
 		return len(self.p_stack)
 
-	def compute_parserstack_frame_allocs(self):
-		stack_depth = 0
-		stack_events = None
-		for index, ev in enumerate(self.stack_events[::-1]):
-			# Since this is meant to be called from ParserStack.pop(), the assumption here is that the first element will be a StackEvent.POP
-			# So we can stop gathering memory allocations at the point stack_depth becomes 0 again: that'll be the point in the list,
-			# where the parser we just popped from the stack had been pushed on it. Allocations prior to that are not relevant and are not considered
-			if ev[0] == StackEvent.POP:
-				stack_depth += 1
-			elif ev[0] == StackEvent.PUSH:
-				stack_depth -= 1
-				if stack_depth == 0:
-					stack_events = self.stack_events[-index-1:]
-					# Possible optimization:
-					# Get only self.stack_events[-1], self.stack_events[-2], self.stack_events[-index-1], self.stack_events[-index]
-					print(stack_events) # DEBUG
-					break
-
-		return self.compute_outer_frame(stack_events)
-
-	#TODO: compute -> calculate
-	def compute_outer_frame(self, stack_slice):
-		if len(stack_slice) == 2:
-			return stack_slice[1][1] - stack_slice[0][1]
-		# The code below assumes len(stíack_slice) >= 4, TODO: ensure that len(stack_slice) is never 3
-		else:
-			# Remove the "outer" frame, call the function recursively on the "inner" frames
-			#new_slice = stack_slice[1:-1]
-			#return (stack_slice[-1][1] - stack_slice[0][1]) - self.compute_outer_frame(new_slice)
-			# alternatively:
-			return (stack_slice[-1][1] - stack_slice[-2][1]) + (stack_slice[1][1] - stack_slice[0][1])
-
-	def calculate_pushes_at_end(self):
-		# TODO: start at self.committed
-		# Throws StopIteration if no more items in the iterator match the condition
-		last_pop = next((index for index,ev in enumerate(self.stack_events[::-1]) if ev[0] == StackEvent.POP), None)
-		# TODO: recursion, attribute each difference to the correct parser
-		if last_pop is None:
-			# No "pop" events in the list, stack_events is all pushes
-			# Subtract the bytes allocated before the first push happened, from the bytes allocated by the most recent h_do_parse()
-			#return self.stack_events[0][1] - self.stack_events[-1][1]
-			#TODO: instead of looping over twice, early-out on the first pop
-			pushes = self.stack_events
-			push_allocations = {parser.address: pushes[index+1][1]-pushes[index][1] for index, parser in enumerate(self.p_stack[:-1])}
-			return push_allocations
-
-		#return self.stack_events[0][1] - self.stack_events[-index][1]
-		pushes = self.stack_events[-(last_pop+1):]
-		parsers = self.p_stack[-last_pop:]
-		print("parsers:", parsers) # DEBUG
-		push_allocations = {parser.address: pushes[index+1][1]-pushes[index][1] for index, parser in enumerate(parsers)}
-		print("push_allocations:", push_allocations) # DEBUG
-		print("push_allocations_with_names:", {parser.name: pushes[index+1][1]-pushes[index][1] for index, parser in enumerate(parsers)}) # DEBUG
-		# TODO: looks like it needs to account for the case where top of stack is a string of pushes, but there are runs of pushes without corresponding pops (yet?) deeper in the stack
-		print("top 30 stack events:", [ev[0] for ev in self.stack_events[-30:]]) # DEBUG
-
-		#for index, ev in enumerate(self.stack_events[::-1]):
-		#	if ev[0] == StackEvent.POP:
-		#		last_pop = index
-
-
 	# Represented by a '(' for push, and ')' pop, a typical list of stack events might look like:
 	# (()(())((()((((()(((((
 
@@ -324,7 +262,6 @@ class ParserStack:
 	# When processing a "pop" event, one of the following is true:
 	# - the index of the corresponding "push" event < self.committed
 	#	- this happens when there was a stop at a HDoParseBreakpoint, and allocations up to the corresponding stack event have been committed to memory stats
-	#	- it also happens if there is a run of "pop" events in the stack_events list
 	# - the index of the corresponding "push" event == self.committed 
 
 	# When processing a "pop" event, one of the following is true:
@@ -412,7 +349,3 @@ class ParserStack:
 	# checking self.committed will show if all the relevant allocations before revisiting the current stack frame have been committed.
 	# - self.stack_events[self.committed] == current_event
 
-
-	def calculate_and_clear_pushes_at_end(self):
-		stats = self.calculate_pushes_at_end()
-		self.committed = len(self.stack_events)-2