LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/cup.cpp
// Function: Cup::execute(StackMachine*)
void Cup::execute(StackMachine *stack)
{	
	stack->fMP = stack->fSP - (fP + 4);
	
	stack->fStore[stack->fMP + 4] = new StackAddress(stack->fPC);
	
	stack->fPC = stack->fLabelCenter.getAddress(fQ);
	
	// adding cost of this instruction
	stack->fTime.count("cup");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xb4(%rsi), %eax
subl 0x8(%rdi), %eax
addl $-0x4, %eax
movl %eax, 0xc0(%rsi)
movl $0x10, %edi
callq 0x6200
movq %rax, %r15
movl 0xb0(%rbx), %esi
movq %rax, %rdi
callq 0x1a3d0
movslq 0xc0(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r15, 0x20(%rcx,%rax,8)
leaq 0x48(%rbx), %rdi
addq $0x10, %r14
movq %r14, %rsi
callq 0x1b51e
movl %eax, 0xb0(%rbx)
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1aa9f(%rip), %rsi     # 0x23460
leaq 0x1aa9b(%rip), %rdx     # 0x23463
leaq -0x38(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x89f6
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x8a2b
movq -0x28(%rbp), %rsi
incq %rsi
jmp 0x8a26
movq %rax, %rbx
jmp 0x8a2b
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/cupi.cpp
// Function: Cupi::execute(StackMachine*)
void Cupi::execute(StackMachine *stack)
{	
	/*
	if(stack->fMP + 4 > stack->fSP)
	{
		for(int i = 0; i < stack->fMP + 4 - stack->fSP; ++i)
		{
			stack->fStore.push_back(new StackElement());
			++stack->fSP;
		}
	}
	else
	{
		delete stack->fStore[stack->fMP + 4];
		stack->fStore[stack->fMP + 4] = 0;
	}
	*/
	
	stack->fStore[stack->fMP + 4] = new StackAddress(stack->fPC);
	
	if(stack->base(fP, stack->fStore[stack->fMP + 2]->getValue()) + fQ > stack->fSP)
	{
		throw ExecutionError("instruction cupi: trying to access a memorylocation above STORE[SP]");
	}
	stack->fPC = stack->fStore[stack->base(fP, stack->fStore[stack->fMP + 2]->getValue()) + fQ]->getValue();
	
	// adding cost of this instruction
	stack->fTime.count("cupi");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x6200
movq %rax, %r15
movl 0xb0(%rbx), %esi
movq %rax, %rdi
callq 0x1a3d0
movslq 0xc0(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r15, 0x20(%rcx,%rax,8)
movl 0x8(%r14), %r15d
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x1d7fc
addl 0xc(%r14), %eax
cmpl 0xb4(%rbx), %eax
jg 0x8c99
movl 0x8(%r14), %r15d
movslq 0xc0(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x1d7fc
movslq 0xc(%r14), %rcx
cltq
addq %rcx, %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, 0xb0(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a85b(%rip), %rsi     # 0x234b2
leaq 0x1a858(%rip), %rdx     # 0x234b6
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x8c8c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a7b8(%rip), %rsi     # 0x2346e
leaq 0x1a7f4(%rip), %rdx     # 0x234b1
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x29da9(%rip), %rsi     # 0x32a88
leaq 0x12750(%rip), %rdx     # 0x1b436
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x8d0e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x8d0e
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x8d47
movq %rbx, %rdi
callq 0x6170
jmp 0x8d47
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x8d47
movq -0x30(%rbp), %rsi
incq %rsi
jmp 0x8d42
movq %rax, %r14
jmp 0x8d47
movq %rax, %r14
movl $0x10, %esi
movq %r15, %rdi
callq 0x6210
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/ent.cpp
// Function: Ent::execute(StackMachine*)
void Ent::execute(StackMachine *stack)
{	
	int oldSP = stack->fSP;
	
	// q data-area size
	stack->fSP = stack->fMP + fQ - 1;
	
	for(int i = oldSP + 1; i <= stack->fSP; ++i)
	{
		stack->fStore.push_back(new StackElement());
	}
	
	// p max depth of local stack
	stack->fEP = stack->fSP + fP;
	
	// adding cost of this instruction
	stack->fTime.count("ent");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl 0xb4(%rsi), %r14d
movl 0xc0(%rsi), %eax
movq %rdi, -0x50(%rbp)
movl 0xc(%rdi), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0xb4(%rsi)
cmpl %eax, %r14d
jge 0xa5f9
leaq 0x18(%rbx), %r15
leaq -0x48(%rbp), %r12
movl $0x8, %edi
callq 0x6200
movq %rax, %r13
movq %rax, %rdi
callq 0x1a5bc
incl %r14d
movq %r13, -0x48(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa3ae
movl 0xb4(%rbx), %eax
cmpl %eax, %r14d
jl 0xa5c7
movq -0x50(%rbp), %rcx
addl 0x8(%rcx), %eax
movl %eax, 0xbc(%rbx)
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1c061(%rip), %rsi     # 0x26676
leaq 0x1c05d(%rip), %rdx     # 0x26679
leaq -0x48(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xa64a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xa683
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0xa67e
movq %rax, %rbx
jmp 0xa683
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/fjp.cpp
// Function: Fjp::execute(StackMachine*)
void Fjp::execute(StackMachine *stack)
{
	StackBoolean p;
	
	if(typeid(p) != typeid(*(stack->fStore[stack->fSP])))
		throw ExecutionError("instruction fjp: requires a boolean te be on top of the stack.");

	if(stack->fStore[stack->fSP]->getBoolean() == false)
	{
		stack->fPC = stack->fLabelCenter.getAddress(fQ);
	}
	
	delete stack->fStore[stack->fSP];
	stack->fStore.pop_back();
	--stack->fSP;
	
	// adding cost of this instruction
	stack->fTime.count("fjp");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1b10c
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0xb423
movq (%r15), %r12
movq -0x8(%r12), %rax
leaq 0x2899d(%rip), %rcx     # 0x33c98
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0xb31e
cmpb $0x2a, (%rdi)
je 0xb3ce
callq 0x6310
testl %eax, %eax
jne 0xb3ce
movq %r15, %rdi
callq *0x70(%r12)
testb %al, %al
jne 0xb340
leaq 0x48(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x1b51e
movl %eax, 0xb0(%rbx)
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xb369
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
addq $-0x8, 0x20(%rbx)
decl 0xb4(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x188b7(%rip), %rsi     # 0x23c3a
leaq 0x188b3(%rip), %rdx     # 0x23c3d
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xb3b8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1b130
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x18810(%rip), %rsi     # 0x23bfb
leaq 0x18847(%rip), %rdx     # 0x23c39
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x27674(%rip), %rsi     # 0x32a88
leaq 0x1001b(%rip), %rdx     # 0x1b436
movq %rbx, %rdi
callq 0x63e0
callq 0x6250
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xb448
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0xb448
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xb476
movq %rbx, %rdi
callq 0x6170
jmp 0xb476
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xb476
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0xb476
jmp 0xb473
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x1b130
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/ixj.cpp
// Function: Ixj::execute(StackMachine*)
void Ixj::execute(StackMachine *stack)
{
	StackInteger p1;
			
	if(typeid(p1) != typeid(*stack->fStore[stack->fSP]))
		throw ExecutionError("instruction ixj: STORE[SP] does not contain an element of type integer.");
		
	stack->fPC = stack->fStore[stack->fSP]->getValue() + stack->fLabelCenter.getAddress(fQ);
	
	delete stack->fStore[stack->fSP];
	stack->fStore.pop_back();
	
	--stack->fSP;
	
	// adding cost of this instruction
	stack->fTime.count("ixj");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1aca0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0xe371
movq (%r15), %r12
movq -0x8(%r12), %rax
leaq 0x258b1(%rip), %rcx     # 0x33af8
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0xe26a
cmpb $0x2a, (%rdi)
je 0xe31c
callq 0x6310
testl %eax, %eax
jne 0xe31c
movq %r15, %rdi
callq *0x68(%r12)
movl %eax, %r15d
leaq 0x48(%rbx), %rdi
addq $0x8, %r14
movq %r14, %rsi
callq 0x1b51e
addl %r15d, %eax
movl %eax, 0xb0(%rbx)
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xe2b7
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
addq $-0x8, 0x20(%rbx)
decl 0xb4(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1638f(%rip), %rsi     # 0x24660
leaq 0x1638b(%rip), %rdx     # 0x24663
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe306
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1acc4
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x162df(%rip), %rsi     # 0x24618
leaq 0x1631f(%rip), %rdx     # 0x2465f
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x24726(%rip), %rsi     # 0x32a88
leaq 0xd0cd(%rip), %rdx      # 0x1b436
movq %rbx, %rdi
callq 0x63e0
callq 0x6250
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe396
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0xe396
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xe3c4
movq %rbx, %rdi
callq 0x6170
jmp 0xe3c4
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe3c4
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0xe3c4
jmp 0xe3c1
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x1acc4
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/lda.cpp
// Function: Lda::execute(StackMachine*)
void Lda::execute(StackMachine *stack)
{
	stack->fStore.push_back(new StackAddress(stack->base(fP, stack->fMP) + fQ));
	
	++stack->fSP;
	
	// adding cost of this instruction
	stack->fTime.count("lda");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0x8(%r15), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1d7fc
addl 0xc(%r15), %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x1a3d0
leaq 0x18(%rbx), %rdi
leaq -0x38(%rbp), %rsi
movq %r14, (%rsi)
callq 0xa3ae
incl 0xb4(%rbx)
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x16199(%rip), %rsi     # 0x2466e
leaq 0x16195(%rip), %rdx     # 0x24671
leaq -0x38(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xe50a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xe53f
movq -0x28(%rbp), %rsi
incq %rsi
jmp 0xe53a
movq %rax, %rbx
jmp 0xe53f
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/mst.cpp
// Function: Mst::execute(StackMachine*)
void Mst::execute(StackMachine *stack)
{	
	for(int i = 0; i < 5; ++i)
	{
		stack->fStore.push_back(new StackElement());
	}

	// static link
	delete stack->fStore[stack->fSP + 2];
	stack->fStore[stack->fSP + 2] = new StackAddress(stack->base(fP, stack->fMP));

	// dynamic link
	delete stack->fStore[stack->fSP + 3];
	stack->fStore[stack->fSP + 3] = new StackAddress(stack->fMP);

	// save EP
	delete stack->fStore[stack->fSP + 4];
	stack->fStore[stack->fSP + 4] = new StackAddress(stack->fEP);
	
	stack->fSP += 5;
	
	// adding cost of this instruction
	stack->fTime.count("mst");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
leaq 0x18(%rsi), %r15
movl $0x5, %r14d
leaq -0x48(%rbp), %r12
movl $0x8, %edi
callq 0x6200
movq %rax, %r13
movq %rax, %rdi
callq 0x1a5bc
movq %r13, -0x48(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa3ae
decl %r14d
jne 0x131b6
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %r15
testq %r15, %r15
je 0x13209
movq %r15, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r15, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r15
movq -0x50(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1d7fc
movq %r15, %rdi
movl %eax, %esi
callq 0x1a3d0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r15, 0x10(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x18(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x13268
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xc0(%rbx), %esi
movq %rax, %rdi
callq 0x1a3d0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x18(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x20(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x132b6
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x1a3d0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x20(%rcx,%rax,8)
addl $0x5, %eax
movl %eax, 0xb4(%rbx)
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x11d89(%rip), %rsi     # 0x25082
leaq 0x11d85(%rip), %rdx     # 0x25085
leaq -0x48(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x1332e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x13383
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0x1337e
movq %rax, %rbx
jmp 0x13383
jmp 0x13359
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0x1337e
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
jmp 0x1337e
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/mstf.cpp
// Function: Mstf::execute(StackMachine*)
void Mstf::execute(StackMachine *stack)
{	
	for(int i = 0; i < 5; ++i)
	{
		stack->fStore.push_back(new StackElement());
	}
	
	// static link
	delete stack->fStore[stack->fSP + 2];
	stack->fStore[stack->fSP + 2] = new StackAddress(stack->fStore[stack->base(fP, stack->fMP) + fQ + 1]->getValue());
	
	// dynamic link
	delete stack->fStore[stack->fSP + 3];
	stack->fStore[stack->fSP + 3] = new StackAddress(stack->fMP);
	
	// save EP
	delete stack->fStore[stack->fSP + 4];
	stack->fStore[stack->fSP + 4] = new StackAddress(stack->fEP);
	
	stack->fSP += 5;
	
	// adding cost of this instruction
	stack->fTime.count("mstf");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
leaq 0x18(%rsi), %r15
movl $0x5, %r14d
leaq -0x48(%rbp), %r12
movl $0x8, %edi
callq 0x6200
movq %rax, %r13
movq %rax, %rdi
callq 0x1a5bc
movq %r13, -0x48(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa3ae
decl %r14d
jne 0x1344a
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rcx,%rax,8), %r15
testq %r15, %r15
je 0x1349d
movq %r15, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r15, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r15
movq -0x50(%rbp), %r14
movl 0x8(%r14), %esi
movl 0xc0(%rbx), %edx
movq %rbx, %rdi
callq 0x1d7fc
movslq 0xc(%r14), %rcx
cltq
addq %rcx, %rax
movq 0x18(%rbx), %rcx
movq 0x8(%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r15, %rdi
movl %eax, %esi
callq 0x1a3d0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r15, 0x10(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x18(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x13515
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xc0(%rbx), %esi
movq %rax, %rdi
callq 0x1a3d0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x18(%rcx,%rax,8)
movq 0x18(%rbx), %rcx
movq 0x20(%rcx,%rax,8), %r14
testq %r14, %r14
je 0x13563
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movl $0x10, %edi
callq 0x6200
movq %rax, %r14
movl 0xbc(%rbx), %esi
movq %rax, %rdi
callq 0x1a3d0
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r14, 0x20(%rcx,%rax,8)
addl $0x5, %eax
movl %eax, 0xb4(%rbx)
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x11aea(%rip), %rsi     # 0x25090
leaq 0x11ae7(%rip), %rdx     # 0x25094
leaq -0x48(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x135db
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x13630
movq -0x38(%rbp), %rsi
incq %rsi
jmp 0x1362b
movq %rax, %rbx
jmp 0x13630
jmp 0x13606
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0x1362b
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
jmp 0x1362b
movq %rax, %rbx
movl $0x8, %esi
movq %r13, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/not.cpp
// Function: Not::execute(StackMachine*)
void Not::execute(StackMachine *stack) 
{
	// check if the stack contains at least one entry
	if(stack->fSP < 0)
		throw ExecutionError("instruction not: requires 1 stackelement to be present.");
		
	StackBoolean p1;
	
	if(typeid(p1) != typeid(*(stack->fStore[stack->fSP])))
		throw ExecutionError("instruction not: SP does not point to element of type boolean.");

	
	// actual not-operation
	stack->fStore[stack->fSP]->noti();
	
	// adding cost of this instruction
	stack->fTime.count("not");

	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x0, 0xb4(%rsi)
js 0x15253
movq %rsi, %rbx
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1b10c
movslq 0xb4(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x152a8
movq (%r14), %r15
movq -0x8(%r15), %rax
leaq 0x1eb18(%rip), %rcx     # 0x33c98
movq 0x8(%rcx), %rdi
movq 0x8(%rax), %rsi
cmpq %rsi, %rdi
je 0x1519b
cmpb $0x2a, (%rdi)
je 0x151fc
callq 0x6310
testl %eax, %eax
jne 0x151fc
movq %r14, %rdi
callq *0x48(%r15)
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x104b3(%rip), %rsi     # 0x25664
leaq 0x104af(%rip), %rdx     # 0x25667
leaq -0x40(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x151e6
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
leaq -0x50(%rbp), %rdi
callq 0x1b130
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1040c(%rip), %rsi     # 0x25625
leaq 0x10443(%rip), %rdx     # 0x25663
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x1d846(%rip), %rsi     # 0x32a88
leaq 0x61ed(%rip), %rdx      # 0x1b436
movq %r14, %rdi
callq 0x63e0
jmp 0x152a8
movl $0x20, %edi
callq 0x6100
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1037d(%rip), %rsi     # 0x255ed
leaq 0x103ad(%rip), %rdx     # 0x25624
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x1d7ef(%rip), %rsi     # 0x32a88
leaq 0x6196(%rip), %rdx      # 0x1b436
movq %r14, %rdi
callq 0x63e0
callq 0x6250
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x152cd
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x152cd
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x15333
movq %r14, %rdi
callq 0x6170
jmp 0x15333
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x152fc
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x152fc
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1532a
movq %r14, %rdi
callq 0x6170
jmp 0x1532a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x1532a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1532a
jmp 0x15327
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1b130
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/ssp.cpp
// Function: Ssp::execute(StackMachine*)
void Ssp::execute(StackMachine *stack)
{	
	int newSPvalue = stack->fMP + fP - 1;

	// get the stack consistent
	if(newSPvalue < stack->fSP)
	{
		for(int i = stack->fSP; i > newSPvalue; --i)
		{	
			delete stack->fStore[i];
			stack->fStore[i] = 0;
			stack->fStore.pop_back();
		}
	}
	else
	{
		for(int i = stack->fSP; i < newSPvalue; ++i)
		{
			stack->fStore.push_back(new StackElement());
		}
	}
	
	stack->fSP = newSPvalue;
	
	// adding cost of this instruction
	stack->fTime.count("ssp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl 0xc0(%rsi), %ecx
movl 0x8(%rdi), %edx
leal (%rdx,%rcx), %eax
addl %edx, %ecx
decl %ecx
movslq 0xb4(%rsi), %r13
cmpl %r13d, %eax
movl %ecx, -0x2c(%rbp)
jle 0x16fa1
cmpl %ecx, %r13d
jge 0x16fe4
leaq 0x18(%rbx), %r14
notl %r13d
addl %eax, %r13d
leaq -0x50(%rbp), %r15
movl $0x8, %edi
callq 0x6200
movq %rax, %r12
movq %rax, %rdi
callq 0x1a5bc
movq %r12, -0x50(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa3ae
decl %r13d
jne 0x16f76
jmp 0x16fe4
movslq %eax, %r15
incq %r13
movq 0x18(%rbx), %rax
movq -0x8(%rax,%r13,8), %r14
testq %r14, %r14
je 0x16fca
movq %r14, %rdi
callq 0x1a5cc
movl $0x8, %esi
movq %r14, %rdi
callq 0x6210
movq 0x18(%rbx), %rax
movq $0x0, -0x8(%rax,%r13,8)
addq $-0x8, 0x20(%rbx)
decq %r13
cmpq %r15, %r13
jg 0x16fa7
movl -0x2c(%rbp), %eax
movl %eax, 0xb4(%rbx)
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xeb00(%rip), %rsi      # 0x25afc
leaq 0xeafc(%rip), %rdx      # 0x25aff
leaq -0x50(%rbp), %rdi
callq 0x746c
addq $0x78, %rbx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x1ce78
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x17031
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x1706a
movq -0x40(%rbp), %rsi
incq %rsi
jmp 0x17065
movq %rax, %rbx
jmp 0x1706a
movq %rax, %rbx
movl $0x8, %esi
movq %r12, %rdi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/out.cpp
// Function: Out::print(std::ostream&) const
ostream& Out::print(ostream &os) const
{
	if(fPrecisionMarker)
		os << "out r i";
	else
		os << "out " << printStackElementType(fType);
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
cmpb $0x1, 0xc(%rdi)
jne 0x1966e
leaq 0xcbb9(%rip), %rsi      # 0x26218
movl $0x7, %edx
movq %rbx, %rdi
callq 0x6270
jmp 0x196bd
movq %rdi, %r14
leaq 0xcba8(%rip), %rsi      # 0x26220
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6270
movl 0x8(%r14), %esi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x73d2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x6270
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x196bd
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x6210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x196e5
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x6210
movq %rbx, %rdi
callq 0x6410
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/stackboolean.cpp
// Function: StackBoolean::print(std::ostream&) const
ostream& StackBoolean::print(ostream &os) const
{
	if(fBoolean)
		os << 't';
	else
		os << 'f';
	return os;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x1b2e2
leaq -0x9(%rbp), %rsi
movb $0x74, (%rsi)
jmp 0x1b2e9
leaq -0xa(%rbp), %rsi
movb $0x66, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6270
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/labelcenter.cpp
// Function: LabelCenter::getAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int LabelCenter::getAddress(const string &kLabel)
{
	map<string, int>::iterator it = fLabels.find(kLabel);
	
	if(it == fLabels.end())
	{
		throw ExecutionError("label " + kLabel + " was not defined");
	}
	
	return fLabels[kLabel] - 1;	/* correction of "-1" because of the fact that the machine
						automatically increments the PC */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1ba3e
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x1b55d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b920
movl (%rax), %eax
decl %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq 0xb26a(%rip), %rsi      # 0x267db
leaq -0x60(%rbp), %rdi
movq %r14, %rdx
callq 0x1b88e
leaq 0xb25e(%rip), %rsi      # 0x267e2
leaq -0x60(%rbp), %rdi
callq 0x6450
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1b5af
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x1b5ba
movq %rdx, -0x40(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x30(%rbp)
movq 0x8(%rax), %rdx
leaq -0x40(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x1749e(%rip), %rsi     # 0x32a88
leaq -0x1bb(%rip), %rdx      # 0x1b436
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b619
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1b619
movq %rax, %r14
movb $0x1, %r15b
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b63a
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1b63a
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1b647
movq %rbx, %rdi
callq 0x6170
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/labelcenter.cpp
// Function: LabelCenter::addAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void LabelCenter::addAddress(const string &kLabel, int location)
{
	map<string, int>::iterator it = fLabels.find(kLabel);
	
	if(it != fLabels.end())
	{
		throw CompileTimeError("Label " + kLabel + " is being redeclared");
	}
	
	fLabels.insert(map<string, int>::value_type(kLabel, location));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1ba3e
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1b6c6
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x8a9a
movl %r15d, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1be06
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b6b9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq 0xb119(%rip), %rsi      # 0x267f3
leaq -0x68(%rbp), %rdi
movq %r14, %rdx
callq 0x1b88e
leaq 0xb10d(%rip), %rsi      # 0x267fa
leaq -0x68(%rbp), %rdi
callq 0x6450
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1b718
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x1b723
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r15b
movq %rbx, %rdi
callq 0x1b484
xorl %r15d, %r15d
leaq 0x1862d(%rip), %rsi     # 0x33d80
leaq -0x2b8(%rip), %rdx      # 0x1b4a2
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b782
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1b782
movq %rax, %r14
movb $0x1, %r15b
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b7a3
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1b7a3
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1b7ca
movq %rbx, %rdi
callq 0x6170
jmp 0x1b7ca
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b7ca
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
movq %r14, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/timecounter.cpp
// Function: TimeCounter::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void TimeCounter::count(const string &kInstruction)
{
	map<string, int>::iterator it = fWeights.find(kInstruction);
	
	if(it == fWeights.end())
	{
		cerr << "illegal instruction entered for counting purposes" << endl;
	}

	fCounter += fWeights[kInstruction];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1ba3e
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1ced8
movq 0x17153(%rip), %r15     # 0x33ff0
leaq 0x9989(%rip), %rsi      # 0x2682d
movl $0x31, %edx
movq %r15, %rdi
callq 0x6270
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b920
movl (%rax), %eax
addl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::run()
void StackMachine::run()
{
	fPC = 0;
	while(fHaltrequested == false)
	{
		if(fPC >= fIC)
		{
			throw ExecutionError("PC has exceeded maximum number of instructions.");
			cerr << "End reached" << endl;
			return;
		}
		else
		{
			if(fStepping)
			{
				printCurrentInstruction();
			}
			fCode[fPC]->execute(this);
			if(fStepping)
			{
				showStack();
				showHeap();
				showParameters();
				continueStep();
			}
			++fPC;
			++fStepCounter;
		}
	}
	
	// print the execution-time
	cout << endl << "--> Execution time: " << fTime.getTime() << endl << endl;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, 0xb0(%rdi)
cmpb $0x0, 0xc4(%rdi)
jne 0x1d137
movl 0xb0(%rbx), %eax
cmpl 0xc8(%rbx), %eax
jge 0x1d1f2
cmpb $0x1, 0xcc(%rbx)
jne 0x1d0e2
movq %rbx, %rdi
callq 0x1d27c
movslq 0xb0(%rbx), %rax
movq (%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
cmpb $0x1, 0xcc(%rbx)
jne 0x1d122
movq %rbx, %rdi
callq 0x1d2e6
movq %rbx, %rdi
callq 0x1d44c
movq %rbx, %rdi
callq 0x1d596
movq %rbx, %rdi
callq 0x1d71e
incl 0xb0(%rbx)
incl 0xd8(%rbx)
cmpb $0x0, 0xc4(%rbx)
je 0x1d0bf
movq 0x16e82(%rip), %r14     # 0x33fc0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %r14
leaq 0x9720(%rip), %rsi      # 0x2688f
movl $0x14, %edx
movq %rax, %rdi
callq 0x6270
addq $0x78, %rbx
movq %rbx, %rdi
callq 0x1cef4
movq %r14, %rdi
movl %eax, %esi
callq 0x63f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6140
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x9650(%rip), %rsi      # 0x2685f
leaq 0x9678(%rip), %rdx      # 0x2688e
leaq -0x40(%rbp), %rdi
callq 0x746c
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x15850(%rip), %rsi     # 0x32a88
leaq -0x1e09(%rip), %rdx     # 0x1b436
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1d267
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1d267
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1d274
movq %rbx, %rdi
callq 0x6170
movq %r14, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::showStack()
void StackMachine::showStack()
{
	int beginvalue;
	
	if(fStackSize == 0)
	{
		beginvalue = 0;
	}
	else
	{
		if(fStore.size() - fStackSize < 0)
		{
			beginvalue = 0;
		}
		else
		{
			beginvalue = fStore.size() - fStackSize;
		}
	}
	
	for(int i = beginvalue; i < fStore.size(); ++i)
	{
		cout << "\t[" << i << "]\t\t" << "[" << fStore[i]->getType() << "]\t" << *fStore[i] << endl;
	}
	cout << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xd4(%rdi), %eax
testl %eax, %eax
je 0x1d314
movq 0x20(%rbx), %rcx
subq 0x18(%rbx), %rcx
shrq $0x3, %rcx
subl %eax, %ecx
movslq %ecx, %r14
jmp 0x1d317
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x3, %rax
cmpq %r14, %rax
jbe 0x1d40e
movq 0x16c8d(%rip), %r15     # 0x33fc0
leaq 0x95a9(%rip), %r12      # 0x268e3
movl $0x2, %edx
movq %r15, %rdi
leaq 0x9593(%rip), %rsi      # 0x268dc
callq 0x6270
movq %r15, %rdi
movl %r14d, %esi
callq 0x63f0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x9574(%rip), %rsi      # 0x268df
callq 0x6270
movl $0x1, %edx
movq %r13, %rdi
leaq 0x955e(%rip), %rsi      # 0x268dd
callq 0x6270
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r13, %rdi
leaq -0x29(%rbp), %rsi
callq 0x6270
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x6270
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %r13, %rdi
callq 0x1abbb
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
incq %r14
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x1d33a
movq 0x16bab(%rip), %rbx     # 0x33fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::showHeap()
void StackMachine::showHeap()
{
	if(fShowHeap)
	{
		for(int i = -1; i >= fNP; --i)
		{
			cout << "\t[" << i << "]\t\t" << "[" << fHeap[-i-1]->getType() << "]\t" << *fHeap[-i-1] << endl;
		}
		cout << endl;
	}
}

// Assembly:
cmpb $0x1, 0xcd(%rdi)
jne 0x1d594
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xb8(%rdi)
jns 0x1d558
xorl %r12d, %r12d
movq 0x16b3f(%rip), %r14     # 0x33fc0
xorl %r13d, %r13d
decl %r13d
movl $0x2, %edx
movq %r14, %rdi
leaq 0x9446(%rip), %rsi      # 0x268dc
callq 0x6270
movq %r14, %rdi
movl %r13d, %esi
callq 0x63f0
movq %rax, %r15
movl $0x3, %edx
movq %rax, %rdi
leaq 0x9427(%rip), %rsi      # 0x268df
callq 0x6270
movl $0x1, %edx
movq %r15, %rdi
leaq 0x9411(%rip), %rsi      # 0x268dd
callq 0x6270
movq 0x30(%rbx), %rax
movq (%rax,%r12), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0x6270
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0x93db(%rip), %rsi      # 0x268e3
callq 0x6270
movq 0x30(%rbx), %rax
movq (%rax,%r12), %rsi
movq %r15, %rdi
callq 0x1abbb
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
addq $0x8, %r12
cmpl 0xb8(%rbx), %r13d
jg 0x1d484
movq 0x16a61(%rip), %rbx     # 0x33fc0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::continueStep()
void StackMachine::continueStep()
{
	if(fStepCounter == fStepSize)
	{
		cout << "Press [c] + [Enter] to continue. Other key to end." << endl;
		char space;
		cin >> space;
		switch(space)
		{
			case 'c': 
			case 'C': break;
			default: exit(0);
		}
		fStepCounter = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0xd8(%rdi), %eax
cmpl 0xd0(%rdi), %eax
jne 0x1d7a5
movq %rdi, %rbx
movq 0x1687f(%rip), %r14     # 0x33fc0
leaq 0x915c(%rip), %rsi      # 0x268a4
movl $0x32, %edx
movq %r14, %rdi
callq 0x6270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq 0x16855(%rip), %rdi     # 0x33fd8
leaq -0x11(%rbp), %r14
movq %r14, %rsi
callq 0x62e0
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x63, %eax
jne 0x1d7ae
movl $0x0, 0xd8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %edi, %edi
callq 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/stackmachine.cpp
// Function: StackMachine::base(int, int)
int StackMachine::base(int p, int a)
{
	if (p == 0)
		return a;
	else
	{
		if(a+1 > fSP)
		{
			strstream errormessage;
			errormessage << "base(" << p << "," << a << ") is trying to access a memorylocation above STORE[SP]";
			throw ExecutionError(errormessage.str());
		}
		else
		{
			return base(p - 1, fStore[a+1]->getValue());
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %r12d
subl $0x1, %r12d
jb 0x1d841
cmpl %ebx, 0xb4(%r15)
jle 0x1d853
movq 0x18(%r15), %rax
movslq %ebx, %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, %ebx
movl %r12d, %r14d
jmp 0x1d819
movl %ebx, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c0(%rbp), %rdi
callq 0x6300
leaq -0x1b0(%rbp), %r15
leaq 0x90a3(%rip), %rsi      # 0x26910
movl $0x5, %edx
movq %r15, %rdi
callq 0x6270
movq %r15, %rdi
movl %r14d, %esi
callq 0x63f0
movq %rax, %r14
leaq 0x906b(%rip), %rsi      # 0x268fa
movl $0x1, %edx
movq %rax, %rdi
callq 0x6270
movq %r14, %rdi
movl %ebx, %esi
callq 0x63f0
leaq 0x9069(%rip), %rsi      # 0x26916
movl $0x36, %edx
movq %rax, %rdi
callq 0x6270
movl $0x20, %edi
callq 0x6100
movq %rax, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x6340
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %rax, %rsi
callq 0x1181e
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1b418
xorl %r15d, %r15d
leaq 0x1518c(%rip), %rsi     # 0x32a88
leaq -0x24cd(%rip), %rdx     # 0x1b436
movq %rbx, %rdi
callq 0x63e0
movq %rax, %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d92f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x6210
jmp 0x1d92f
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1d941
movq %rbx, %rdi
callq 0x6170
jmp 0x1d941
movq %rax, %r14
leaq -0x1c0(%rbp), %rdi
callq 0x6440
movq %r14, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/zerolfx[P]P-Machine/main.cpp
// Function: usage()
void usage()
{
	cout << "USAGE: Pmachine [filename] <-s [numeric value]> <-t [numeric value]> <-h>" << endl << endl;
	cout << "\t -s: stepsize" << endl;
	cout << "\t -t: number of stackplaces to show\t(by default all)" << endl;
	cout << "\t -h: show heap" << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x1651a(%rip), %rbx     # 0x33fc0
leaq 0x8ea0(%rip), %rsi      # 0x2694d
movl $0x49, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
leaq 0x8e85(%rip), %rsi      # 0x26997
movl $0xe, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
leaq 0x8e59(%rip), %rsi      # 0x269a6
movl $0x34, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
leaq 0x8e53(%rip), %rsi      # 0x269db
movl $0xf, %edx
movq %rbx, %rdi
callq 0x6270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6140
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x61d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6140
// File: /workspace/github_cpp_makefile_star2_O1/calebstewart[P]md5/./examples/iterative.cpp
// Function: main
int main(int argc, char** argv)
{
  char digest[33];
  unsigned char hash[16];
  char chunk[512];
  MD5 md5;
  std::fstream data_file;

  // Open the executable itself for reading
  data_file.open(argv[0], std::ios::in);

  // Read until there's no more data and add it to the hash
  do {
    data_file.read(chunk, 512);
    md5.update(chunk, data_file.gcount());
  } while ( ! data_file.eof() );

  // Retrieve the final hash
  md5.finalize(hash);

  // If you'd like to reuse the MD5 object to calculate new hashes,
  // you must call reset to ensure you don't continue calculating from
  // the previous data.
  // md5.reset();

  // Output a hex digest
  MD5::digest(hash, digest);
  std::cout << "md5sum " << argv[0] << " => \"" << digest << "\"\n";

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x540, %rsp            # imm = 0x540
movq %rsi, %rbx
leaq -0x360(%rbp), %rdi
callq 0x122c
leaq -0x270(%rbp), %r14
movq %r14, %rdi
callq 0x10a0
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x1080
leaq -0x560(%rbp), %r15
leaq -0x360(%rbp), %r12
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x10b0
movq -0x268(%rbp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x12ac
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x250(%rbp,%rax)
je 0x229a
leaq -0x360(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1fcc
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2212
movq 0x2ce3(%rip), %r14      # 0x4fd8
leaq 0xd25(%rip), %rsi       # 0x3021
movl $0x7, %edx
movq %r14, %rdi
callq 0x1090
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x232d
movq %rbx, %rdi
callq 0x1040
movq 0x2cb8(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1090
jmp 0x2345
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x10d0
movq 0x2c8c(%rip), %rdi      # 0x4fd8
leaq 0xcd6(%rip), %rsi       # 0x3029
movl $0x5, %edx
callq 0x1090
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x1040
movq 0x2c68(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1090
movq 0x2c56(%rip), %rdi      # 0x4fd8
leaq 0xca6(%rip), %rsi       # 0x302f
movl $0x2, %edx
callq 0x1090
leaq -0x270(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x540, %rsp            # imm = 0x540
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23b3
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O1/pstuifzand[P]magento-tools/src/position.cpp
// Function: root_start_element_handler(void*, char const*, char const**)
void root_start_element_handler(void* udata, const XML_Char* name, const XML_Char** atts)
{
    user_data* data = (user_data*)udata;
    data->stack.push_back(std::string(name));

    if (data->state == State::NOT_FOUND) {
        if (XML_GetCurrentLineNumber(data->parser->handle()) >= data->line
         && XML_GetCurrentColumnNumber(data->parser->handle()) >= data->col) {
            data->state = State::FOUND;
            print_stack(data->stack.begin(), data->stack.end());
            std::cout << "\n";
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x29d2
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d78
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2464
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
cmpl $0x0, 0x30(%rbx)
jne 0x24c0
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x20e0
movslq 0x28(%rbx), %rcx
cmpq %rcx, %rax
jb 0x24c0
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x2150
movslq 0x2c(%rbx), %rcx
cmpq %rcx, %rax
jb 0x24c0
movl $0x1, 0x30(%rbx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x2a0f
movq 0x2b21(%rip), %rdi      # 0x4fd0
leaq 0xb6a(%rip), %rsi       # 0x3020
movl $0x1, %edx
callq 0x2190
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24e8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/pstuifzand[P]magento-tools/src/position.cpp
// Function: root_end_element_handler(void*, char const*)
void root_end_element_handler(void* udata, const XML_Char* name)
{
    user_data* data = (user_data*)udata;
    if (data->state == State::NOT_FOUND) {
        if (XML_GetCurrentLineNumber(data->parser->handle()) >= data->line
         && XML_GetCurrentColumnNumber(data->parser->handle()) >= data->col) {
            data->state = State::FOUND;
            print_stack(data->stack.begin(), data->stack.end());
            std::cout << "\n";
        }
    }
    data->stack.pop_back();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
jne 0x2550
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x20e0
movslq 0x28(%rbx), %rcx
cmpq %rcx, %rax
jb 0x2550
movq 0x20(%rbx), %rax
movq (%rax), %rdi
callq 0x2150
movslq 0x2c(%rbx), %rcx
cmpq %rcx, %rax
jb 0x2550
movl $0x1, 0x30(%rbx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x2a0f
movq 0x2a91(%rip), %rdi      # 0x4fd0
leaq 0xada(%rip), %rsi       # 0x3020
movl $0x1, %edx
callq 0x2190
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x2575
movq (%rax), %rsi
incq %rsi
popq %rbx
jmp 0x2170
popq %rbx
retq