LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: read_a_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string read_a_line(std::string p){
	std::string read;
	std::cout << p;
	if (!std::getline(std::cin, read)){
		std::cout << "error reading line\n";
		exit(1); // 1 is an error code
	}
	return read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
leaq 0x1083e6(%rip), %rdi    # 0x120980
movq %rax, %rsi
callq 0x97cf0
leaq 0x1084f7(%rip), %rdi    # 0x120aa0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x78e40
movsbl %al, %edx
leaq 0x1084dc(%rip), %rdi    # 0x120aa0
movq %rbx, %rsi
callq 0x2e410
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x185e8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x108391(%rip), %rdi    # 0x120980
leaq 0xc1b12(%rip), %rsi     # 0xda108
callq 0x98220
movl $0x1, %edi
callq 0x15150
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1861b
movq (%r15), %rsi
incq %rsi
callq 0x2b980
movq %r14, %rdi
callq 0xd6fc0
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: replace_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string replace_str (std::string str, int start, int end, std::string new_str) {
	std::string result = str.substr(0,start);
	result += new_str;
	result += str.substr(std::min((int)str.size(), end));
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r12
movl %ecx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %rcx
xorl %edx, %edx
callq 0xaac30
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xa9bf0
movl 0x8(%r14), %eax
cmpl %r15d, %eax
cmovll %eax, %r15d
movslq %r15d, %rdx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0xaac30
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0xa9bf0
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x186f7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2b980
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1872a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2b980
jmp 0x1872a
jmp 0x18727
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x18741
movq (%rbx), %rsi
incq %rsi
callq 0x2b980
movq %r14, %rdi
callq 0xd6fc0
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: add(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string add(std::vector<std::string> nums){
	int acc = 0;
	for (std::string i : nums) {
		if (std::regex_match(i, is_number)) { acc += std::stoi(i); }
	}
	return std::to_string(acc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x78(%rbp)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
xorl %r14d, %r14d
cmpq %r13, %r12
je 0x1911d
leaq -0x40(%rbp), %r15
movq %r15, -0x50(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x1bc32
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rdx
leaq 0x106939(%rip), %rcx    # 0x11f9b8
xorl %r8d, %r8d
callq 0x28191
movl %eax, %ebx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x1909e
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2b980
testb %bl, %bl
je 0x190fb
movq -0x50(%rbp), %r15
callq 0x154c0
movq %rax, %rbx
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%rbx)
movq %r15, %rdi
leaq -0x70(%rbp), %rsi
movl $0xa, %edx
callq 0x15400
cmpq %r15, -0x70(%rbp)
je 0x191c0
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x191cc
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x191cc
testl %ecx, %ecx
jne 0x190f4
movl -0x2c(%rbp), %ecx
movl %ecx, (%rbx)
addl %eax, %r14d
leaq -0x40(%rbp), %r15
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x19110
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2b980
addq $0x20, %r12
cmpq %r13, %r12
jne 0x19045
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
movl $0x1, %r12d
cmpl $0xa, %r15d
jb 0x1917d
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r15d, %ecx
cmpl $0x63, %ecx
jbe 0x19174
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x1917a
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x1917d
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x19141
addl $-0x3, %r12d
jmp 0x1917d
addl $-0x2, %r12d
jmp 0x1917d
decl %r12d
shrl $0x1f, %r14d
leal (%r12,%r14), %esi
movq -0x78(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0xa7ee0
addq (%rbx), %r14
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x1ba8f
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc1123(%rip), %rdi     # 0xda2ea
callq 0x17262
leaq 0xc1117(%rip), %rdi     # 0xda2ea
callq 0x17312
movq %rax, %r15
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x191ff
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2b980
jmp 0x191ff
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x191ff
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x19218
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2b980
movq %r15, %rdi
callq 0xd6fc0
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: mul(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string mul(std::vector<std::string> nums){
	long int acc = 1;
	for (std::string i : nums) {
		if (std::regex_match(i, is_number)) {
			acc *= std::stol(i);
		}
	}
	return std::to_string(acc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x78(%rbp)
movq (%rsi), %r12
movq 0x8(%rsi), %r15
movl $0x1, %r14d
cmpq %r15, %r12
je 0x19677
leaq -0x50(%rbp), %r13
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x1bc32
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rdx
leaq 0x1063df(%rip), %rcx    # 0x11f9b8
xorl %r8d, %r8d
callq 0x28191
movl %eax, %ebx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x195f8
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2b980
testb %bl, %bl
je 0x19651
movq %r15, %r13
movq -0x50(%rbp), %r15
callq 0x154c0
movq %rax, %rbx
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%rbx)
movq %r15, %rdi
leaq -0x70(%rbp), %rsi
movl $0xa, %edx
callq 0x15400
cmpq %r15, -0x70(%rbp)
je 0x19724
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x19641
cmpl $0x22, %ecx
jne 0x19646
jmp 0x19730
movl -0x2c(%rbp), %ecx
movl %ecx, (%rbx)
imulq %rax, %r14
movq %r13, %r15
leaq -0x50(%rbp), %r13
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1966a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2b980
addq $0x20, %r12
cmpq %r15, %r12
jne 0x1959c
movq %r14, %r15
negq %r15
cmovsq %r14, %r15
movl $0x1, %r12d
cmpq $0xa, %r15
jb 0x196e1
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x196d8
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x196de
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x196e1
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r12d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x196a0
addl $-0x3, %r12d
jmp 0x196e1
addl $-0x2, %r12d
jmp 0x196e1
decl %r12d
shrq $0x3f, %r14
leal (%r14,%r12), %esi
movq -0x78(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0xa7ee0
addq (%rbx), %r14
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x1bb01
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc0bc4(%rip), %rdi     # 0xda2ef
callq 0x17262
leaq 0xc0bb8(%rip), %rdi     # 0xda2ef
callq 0x17312
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x19763
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
jmp 0x19763
movq %rax, %r15
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x19763
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2b980
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1977c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2b980
movq %r15, %rdi
callq 0xd6fc0
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: makefun(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string makefun(std::vector<std::string> exprs){
	std::string aexpr = *(exprs.begin()+1);
	std::cout << aexpr << endl;
	usfuns_map[*exprs.begin()] = "[_xfun \"" + aexpr + "\"]";
	return usfuns_map[*exprs.begin()];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x1bc32
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x10681e(%rip), %rdi    # 0x120980
callq 0x97cf0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x78e40
movsbl %al, %esi
movq %r15, %rdi
callq 0x977f0
movq %rax, %rdi
callq 0x96dc0
leaq 0xc003b(%rip), %rsi     # 0xda1d3
leaq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x1b851
leaq 0xc002d(%rip), %rsi     # 0xda1dc
leaq -0x88(%rbp), %rdi
callq 0xa9d30
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1a1df
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x1a1e7
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
leaq 0x105738(%rip), %rdi    # 0x11f940
callq 0x1b56e
leaq -0x48(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xa85d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x1a230
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2b980
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a249
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2b980
movq (%r14), %rsi
leaq 0x1056ed(%rip), %rdi    # 0x11f940
callq 0x1b56e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1bc32
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a286
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2b980
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1a2b5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2b980
jmp 0x1a2b5
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a2d7
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2b980
jmp 0x1a2d7
jmp 0x1a2d4
jmp 0x1a2d4
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a2ec
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2b980
movq %rbx, %rdi
callq 0xd6fc0
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: bit_(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string bit_(std::vector<std::string> binds){
	if (binds.size() < 2){
		return "too few arguments for _bit";
	}
	if (binds[1].size() > 1){
		return "this value is to big, use 'bits' or 'let' instead";
	}
	vars[binds[0]] = binds[1];
	return vars[binds[0]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
ja 0x1a32c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfebc(%rip), %rsi     # 0xda1df
leaq 0xbfecf(%rip), %rdx     # 0xda1f9
jmp 0x1a348
cmpq $0x2, 0x28(%rsi)
jb 0x1a352
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfeb9(%rip), %rsi     # 0xda1fa
leaq 0xbfee3(%rip), %rdx     # 0xda22b
movq %rbx, %rdi
callq 0x1bccc
jmp 0x1a394
leaq 0x20(%rsi), %r15
leaq 0x10562b(%rip), %r12    # 0x11f988
movq %r12, %rdi
callq 0x1b56e
movq %rax, %rdi
movq %r15, %rsi
callq 0xa81b0
movq (%r14), %rsi
movq %r12, %rdi
callq 0x1b56e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1bc32
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: let_(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string let_(std::vector<std::string> binds){
	if (binds.size() < 2){
		return "too few arguments for _let";
	}
	vars[binds[0]] = binds[1];
	return vars[binds[0]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
ja 0x1a3e0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfe5d(%rip), %rsi     # 0xda22c
leaq 0xbfe70(%rip), %rdx     # 0xda246
movq %rbx, %rdi
callq 0x1bccc
jmp 0x1a422
leaq 0x20(%rsi), %r15
leaq 0x10559d(%rip), %r12    # 0x11f988
movq %r12, %rdi
callq 0x1b56e
movq %rax, %rdi
movq %r15, %rsi
callq 0xa81b0
movq (%r14), %rsi
movq %r12, %rdi
callq 0x1b56e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1bc32
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TsukiGva2[P]Blade-lang/blade.cpp
// Function: at(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string _at(std::vector<std::string> args){ // @ -> at -> Append To.
	if (args.size() < 2){
		return "too few arguments for appendTo";
	}
	std::string result = args[0];
	std::vector<std::string> argsbf(args.begin()+1, args.end());
	for (std::string i : argsbf){
		result += i;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
cmpq $0x20, %rcx
ja 0x1a7ce
leaq 0xbfac4(%rip), %rsi     # 0xda27e
leaq 0xbfadb(%rip), %rdx     # 0xda29c
movq %rbx, %rdi
callq 0x1bccc
jmp 0x1a863
movq %rsi, %r14
movq %rdx, -0x30(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1bc32
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq $0x20, %rsi
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rcx
callq 0x1b810
movq -0x68(%rbp), %r12
movq -0x60(%rbp), %r15
cmpq %r15, %r12
je 0x1a85a
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r14
movq %r13, -0x50(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x1bc32
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0xa9bf0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x1a851
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2b980
addq $0x20, %r12
cmpq %r15, %r12
jne 0x1a814
leaq -0x68(%rbp), %rdi
callq 0x1b252
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1a8a0
movq %rax, %r14
jmp 0x1a897
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x1a897
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2b980
leaq -0x68(%rbp), %rdi
callq 0x1b252
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x1a8b8
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2b980
movq %r14, %rdi
callq 0xd6fc0
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/Block.cpp
// Function: operator<<(std::ostream&, Block const&)
std::ostream& operator<<(std::ostream& out, const Block& b) {
  if (b.leaf_id != -1) {
    out << "Block (leaf, t, k, v) = " << b.leaf_id << " " << b.t << " " << b.k << " [ ";
    for (std::byte byte : b.v) {
      out << std::to_integer<int>(byte) << " ";
    }
    out << "]";
  } else {
    out << "Dummy block";
  }
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, (%rsi)
je 0x2736
movq %rsi, %r14
leaq 0x4977(%rip), %rsi      # 0x7004
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2190
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2240
movq %rax, %r12
leaq 0x4bde(%rip), %r15      # 0x728d
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x2140
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movl 0x10(%r14), %esi
movq %r12, %rdi
callq 0x2240
leaq 0x492c(%rip), %rsi      # 0x701d
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
xorl %r12d, %r12d
movzbl 0x14(%r14,%r12), %esi
movq %rbx, %rdi
callq 0x2240
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
incq %r12
cmpq $0x20, %r12
jne 0x2701
leaq 0x48f2(%rip), %rsi      # 0x7021
movl $0x1, %edx
jmp 0x2742
leaq 0x48e6(%rip), %rsi      # 0x7023
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2190
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/Bucket.cpp
// Function: Bucket::removeBlock(long)
std::optional<Block> Bucket::removeBlock(long t) {
  int removed_index = -1;
  for (int i = 0; i < this->blocks.size(); i++) {
    if (this->blocks.at(i).t == t) {
      removed_index = i;
      break;
    }
  }

  if (removed_index == -1) {
    return std::nullopt;
  } else {
    Block removed_copy = Block(this->blocks.at(removed_index));
    this->blocks.erase(this->blocks.begin() + removed_index);
    return std::optional<Block>{removed_copy};
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rdi
movq 0x40(%rsi), %rdx
movq %rdx, %rsi
subq %rdi, %rsi
sarq $0x3, %rsi
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rsi, %rax
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rdi, %rdx
je 0x28ac
cmpq $0x1, %rax
movq %rax, %r8
adcq $0x0, %r8
leaq 0x8(%rdi), %r10
xorl %r9d, %r9d
cmpq %rcx, (%r10)
je 0x28a9
incq %r9
addq $0x38, %r10
cmpq %r9, %r8
jne 0x2896
jmp 0x28ac
movl %r9d, %esi
cmpl $-0x1, %esi
je 0x2925
movslq %esi, %rsi
cmpq %rsi, %rax
jbe 0x2934
imulq $0x38, %rsi, %rax
leaq (%rdi,%rax), %rsi
addq $0x38, %rsi
movq -0x8(%rsi), %rcx
movq %rcx, 0x30(%rsp)
movups -0x38(%rsi), %xmm0
movups -0x28(%rsi), %xmm1
movups -0x18(%rsi), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpq %rdx, %rsi
je 0x28f8
addq %rax, %rdi
subq %rsi, %rdx
callq 0x2210
addq $-0x38, 0x40(%r14)
movq 0x30(%rsp), %rax
movq %rax, 0x30(%rbx)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $0x1, 0x38(%rbx)
jmp 0x2929
movb $0x0, 0x38(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x475e(%rip), %rdi      # 0x7099
movq %rax, %rdx
xorl %eax, %eax
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/Bucket.cpp
// Function: Bucket::setMaxSize(int)
void Bucket::setMaxSize(int maximum_size) {
  if (Bucket::is_init) {
    throw std::runtime_error("Max Bucket Size was already set");
  }
  Bucket::max_size = maximum_size;
  Bucket::is_init = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x880c(%rip)      # 0xb163
je 0x296e
movl %edi, 0x87f1(%rip)      # 0xb150
movb $0x1, 0x87fd(%rip)      # 0xb163
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x46dd(%rip), %rsi      # 0x705f
movq %rax, %rdi
callq 0x2090
movq 0x865f(%rip), %rsi      # 0xaff0
movq 0x8630(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::findMin()
Block OHeapReadPathEviction::findMin() {
  Block ret = this->onlyFindMin();

  if (this->type_hiding_security) {
    this->onlyDeleteBlock(-1, -1);
    this->insertDummyBlock();
  }

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4024
cmpb $0x1, 0x28(%r14)
jne 0x4018
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x4112
movq %r14, %rdi
callq 0x454a
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::onlyFindMin()
Block OHeapReadPathEviction::onlyFindMin() {
  Block min = this->storage->readBucket(P(0,0)).subtree_min;
  if (this->stash.size() > 0) {
    const Block& stash_min = *std::min_element(this->stash.begin(), this->stash.end());
    if (stash_min < min) {
      min = stash_min;
    }
  }
  return min;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x30(%rsi), %r15
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x30(%rax)
movq (%r15), %rcx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl %eax, %edx
callq *0x8(%rcx)
movq 0x30(%r12), %rax
movq %rax, 0x30(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x38(%r12), %rdi
testq %rdi, %rdi
je 0x4095
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x40(%r14), %r15
movq 0x48(%r14), %r13
cmpq %r15, %r13
je 0x4100
leaq 0x38(%r15), %r12
cmpq %r13, %r12
je 0x40ce
movq %r12, %rdi
movq %r15, %rsi
callq 0x2609
movq %r12, %r14
testb %al, %al
jne 0x40c0
movq %r15, %r14
addq $0x38, %r12
movq %r14, %r15
cmpq %r13, %r12
jne 0x40ab
jmp 0x40d1
movq %r15, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2609
testb %al, %al
je 0x4100
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::onlyDeleteBlock(int, long)
Block OHeapReadPathEviction::onlyDeleteBlock(int leaf, long t) {
  // try to delete from stash
  int removed_index = -1;
  for (int i = 0; i < stash.size(); i++) {
    Block& stash_block_ref = stash.at(i);
    if (stash_block_ref.leaf_id == leaf && stash_block_ref.t == t) {
      removed_index = i;
      break;
    }
  }

  Block stash_block = Block();
  if (removed_index != -1) {
    stash_block = Block(stash.at(removed_index));
    stash.erase(stash.begin() + removed_index);
  }

  // try to delete from storage (dummy ops if block was found in stash)
  Block storage_block = this->readAndRemove(leaf, t);
  this->evictAndUpdateMin(leaf);

  if (stash_block.t != -1) {
    return stash_block;
  } else {
    return storage_block;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
subq %rax, %rcx
je 0x418d
sarq $0x3, %rcx
imulq %rdx, %rcx
cmpq $0x1, %rcx
adcq $-0x1, %rcx
addq $0x8, %rax
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %edx, %edx
movl %r13d, %esi
cmpl %ebp, -0x8(%rax)
sete %dil
cmpq %r15, (%rax)
sete %r8b
movl %edx, %r13d
testb %r8b, %dil
cmovel %esi, %r13d
jne 0x4193
leaq 0x1(%rdx), %rsi
addq $0x38, %rax
cmpq %rdx, %rcx
movq %rsi, %rdx
jne 0x415e
jmp 0x4193
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %rsp, %r12
movq %r12, %rdi
callq 0x25e8
cmpl $-0x1, %r13d
je 0x4212
movslq %r13d, %rsi
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rdx
movq %rdx, %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rax
cmpq %rsi, %rax
jbe 0x4272
imulq $0x38, %rsi, %rax
leaq (%rdi,%rax), %rsi
addq $0x38, %rsi
movups -0x38(%rsi), %xmm0
movups -0x28(%rsi), %xmm1
movups -0x18(%rsi), %xmm2
movl -0x8(%rsi), %ecx
movl %ecx, 0x30(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpq %rdx, %rsi
je 0x420d
addq %rax, %rdi
subq %rsi, %rdx
callq 0x2210
addq $-0x38, 0x48(%r14)
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x4a98
movq %r14, %rdi
movl %ebp, %esi
callq 0x45a2
cmpq $-0x1, 0x8(%rsp)
cmoveq %r13, %r12
movq 0x30(%r12), %rax
movq %rax, 0x30(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e20(%rip), %rdi      # 0x7099
movq %rax, %rdx
xorl %eax, %eax
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::deleteBlock(int, long)
Block OHeapReadPathEviction::deleteBlock(int leaf, long t) {
  if (this->type_hiding_security) {
    this->onlyFindMin();
  }
    
  Block ret = this->onlyDeleteBlock(leaf, t);
    
  if (this->type_hiding_security) {
    this->insertDummyBlock();
  }

  this->t++;
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x28(%rsi)
jne 0x42b0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4024
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x4112
cmpb $0x1, 0x28(%rbx)
jne 0x42ce
movq %rbx, %rdi
callq 0x454a
incq 0x20(%rbx)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::insertBlock(int, std::array<std::byte, 32ul>)
std::pair<int, int> OHeapReadPathEviction::insertBlock(int k, std::array<std::byte, Block::BLOCK_SIZE> v) {
  if (this->type_hiding_security) {
    this->onlyFindMin();
    this->onlyDeleteBlock(-1, -1);
  }

  auto ret = std::pair<int, int>(-1, -1);

  if (k != INT_MAX) {
    ret = this->onlyInsertBlock(k, v);
  } else {
    this->insertDummyBlock();
  }

  this->t++;
  return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x4317
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x4024
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x4112
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0x4330
movq %rbx, %rdi
callq 0x454a
movq $-0x1, %rax
jmp 0x434f
leaq 0x70(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x435a
incq 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::onlyInsertBlock(int, std::array<std::byte, 32ul>)
std::pair<int, int> OHeapReadPathEviction::onlyInsertBlock(int k, std::array<std::byte, Block::BLOCK_SIZE> v) {
  auto ret = std::pair<int, int>();

  int leaf = this->rand_gen->getRandomLeaf();
  stash.push_back(Block(leaf, this->t, k, v));
  
  ret.first = leaf;
  ret.second = this->t;

  this->evictAfterInsert();

  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq 0x20(%rbx), %rdx
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x28(%rsp), %rdi
movl %eax, %esi
movl %r14d, %ecx
callq 0x25cc
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
je 0x43d3
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsi)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups 0x48(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x38, 0x48(%rbx)
jmp 0x43e1
leaq 0x40(%rbx), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5538
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x454a
shlq $0x20, %r14
movl %ebp, %eax
orq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::extractMin()
Block OHeapReadPathEviction::extractMin() {
  Block min_block = this->onlyFindMin();
  Block ret = this->onlyDeleteBlock(min_block.leaf_id, min_block.t);

  if (this->type_hiding_security) {
    this->insertDummyBlock();
  }

  this->t++;
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4024
movl (%r15), %edx
movq 0x8(%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4112
cmpb $0x1, 0x28(%rbx)
jne 0x443c
movq %rbx, %rdi
callq 0x454a
incq 0x20(%rbx)
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::decreaseKey(int, long)
std::pair<int, int> OHeapReadPathEviction::decreaseKey(int leaf, long t) {
  if (this->type_hiding_security) {
    this->onlyFindMin();
  }

  Block old_block = this->onlyDeleteBlock(leaf, t);
  auto ret = this->onlyInsertBlock(old_block.k - 1, old_block.v);

  this->t++;
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x4473
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x4024
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x4112
movl 0x10(%r15), %esi
decl %esi
movups 0x14(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x24(%r15), %xmm0
movaps %xmm0, 0x30(%rsp)
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x435a
incq 0x20(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::increaseKey(int, long)
std::pair<int, int> OHeapReadPathEviction::increaseKey(int leaf, long t) {
  if (this->type_hiding_security) {
    this->onlyFindMin();
  }

  Block old_block = this->onlyDeleteBlock(leaf, t);
  auto ret = this->onlyInsertBlock(old_block.k + 1, old_block.v);

  this->t++;
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x44f1
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x4024
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x4112
movl 0x10(%r15), %esi
incl %esi
movups 0x14(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x24(%r15), %xmm0
movaps %xmm0, 0x30(%rsp)
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x435a
incq 0x20(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::evictAfterInsert()
void OHeapReadPathEviction::evictAfterInsert() {
  // two random paths non-overlapping except at the root
  // = random leaf_id in the first half and random leaf_id in the second half (over all leaf_ids)
  int random_leaf_one = this->rand_gen->getRandomLeaf()/2;
  int random_leaf_two = this->rand_gen->getRandomLeaf()/2 + this->num_leaves/2;

  this->evictAndUpdateMin(random_leaf_one);
  this->evictAndUpdateMin(random_leaf_two);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl 0x10(%rbx), %eax
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
addl %ecx, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45a2
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x45a2
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::readAndRemove(int, long)
Block OHeapReadPathEviction::readAndRemove(int leaf, long t) {
  if (leaf != -1 && t != -1) {
    Block ret;    
    for (int l = 0; l < this->num_levels; l++) {
      int p = this->P(leaf, l);
      Bucket bucket_on_path = this->storage->readBucket(p);
      std::optional<Block> possible_ret = bucket_on_path.removeBlock(t);
      if (possible_ret.has_value()) {
        ret = possible_ret.value();
        bucket_on_path.addBlock(Block());  // for obliviousness
      }
      this->storage->writeBucket(p, bucket_on_path);
    }
    return ret;
  } else {
    // dummy ops
    leaf = this->rand_gen->getRandomLeaf();
    for (int l = 0; l < num_levels; l++) {
      int p = this->P(leaf, l);
      Bucket b = this->storage->readBucket(p);
      this->storage->writeBucket(p, b);
    }
    return Block();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
cmpl $-0x1, %edx
sete %al
movq %rcx, 0x8(%rsp)
cmpq $-0x1, %rcx
sete %cl
orb %al, %cl
movq %rdi, (%rsp)
jne 0x4b9d
movl %edx, %ebx
callq 0x25e8
cmpl $0x0, 0xc(%r14)
jle 0x4c11
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
movl %r12d, %edx
callq *0x30(%rax)
movl %eax, %r15d
movq 0x30(%r14), %rsi
movq (%rsi), %rax
movq %r13, %rdi
movl %r15d, %edx
callq *0x8(%rax)
leaq 0x60(%rsp), %rdi
movq %r13, %rsi
movq 0x8(%rsp), %rdx
callq 0x284a
cmpb $0x1, 0x98(%rsp)
jne 0x4b67
movl 0x90(%rsp), %eax
movq (%rsp), %rcx
movl %eax, 0x30(%rcx)
movups 0x60(%rsp), %xmm0
movups 0x70(%rsp), %xmm1
movups 0x80(%rsp), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
leaq 0xa0(%rsp), %rbp
movq %rbp, %rdi
callq 0x25e8
movq %r13, %rdi
movq %rbp, %rsi
callq 0x27ea
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movl %r15d, %esi
movq %r13, %rdx
callq *0x10(%rax)
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x4b8e
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
incl %r12d
cmpl 0xc(%r14), %r12d
jl 0x4ae4
jmp 0x4c11
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x0, 0xc(%r14)
jle 0x4c08
movl %eax, %ebp
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq *0x30(%rax)
movl %eax, %r13d
movq 0x30(%r14), %rsi
movq (%rsi), %rax
movq %r12, %rdi
movl %r13d, %edx
callq *0x8(%rax)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movl %r13d, %esi
movq %r12, %rdx
callq *0x10(%rax)
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x4bff
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
incl %r15d
cmpl 0xc(%r14), %r15d
jl 0x4bb7
movq (%rsp), %rdi
callq 0x25e8
movq (%rsp), %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c2b
jmp 0x4c2b
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x4c45
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/RandomForOHeap.cpp
// Function: RandomForOHeap::RandomForOHeap()
RandomForOHeap::RandomForOHeap() {
  if (RandomForOHeap::is_initialized) {
    throw std::runtime_error("Only one random instance can be used at a time!");
  }

  this->bound = -1;
  rnd_generator.seed(0L);
  this->seed = (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1);
  RandomForOHeap::is_initialized  = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4d15(%rip), %rax      # 0xad20
movq %rax, (%rdi)
movq $0x1, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
cmpb $0x1, 0x5144(%rip)      # 0xb169
je 0x6053
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rdi)
movabsq $0x5deece66d, %rax      # imm = 0x5DEECE66D
movq %rax, 0x18(%rdi)
movb $0x1, 0x511e(%rip)      # 0xb169
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x126a(%rip), %rsi      # 0x72d1
movq %rax, %rdi
callq 0x2090
movq 0x4f7a(%rip), %rsi      # 0xaff0
movq 0x4f4b(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/RandomForOHeap.cpp
// Function: RandomForOHeap::getRandomLeaf()
int RandomForOHeap::getRandomLeaf() {
  if (this->bound == -1) {
    throw std::runtime_error("Bound is not set.");
  }

  long next = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);
  this->seed = next;
  int bits = next >> (48 - 31);
  if ((this->bound & -this->bound) == this->bound) {  // if bound is a power of 2
    return (int)((this->bound * (long)bits) >> 31);
  }
  int val = bits % this->bound;
  while (bits - val + (this->bound-1) < 0) {
    next = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1);
    this->seed = next;
    bits = next >> (48 - 31);
    val = bits % this->bound;
  }
  return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x8(%rdi), %rsi
cmpq $-0x1, %rsi
je 0x612e
movabsq $0xffffffffffff, %r8    # imm = 0xFFFFFFFFFFFF
movabsq $0x5deece66d, %r9       # imm = 0x5DEECE66D
movq 0x18(%rdi), %rcx
imulq %r9, %rcx
addq $0xb, %rcx
andq %r8, %rcx
movq %rcx, 0x18(%rdi)
shrq $0x11, %rcx
leal -0x1(%rsi), %eax
testl %eax, %esi
jne 0x60e8
imulq %rsi, %rcx
shrq $0x1f, %rcx
movl %ecx, %edx
jmp 0x6124
leal -0x1(%rsi), %r10d
movl %ecx, %eax
xorl %edx, %edx
idivl %esi
movl %r10d, %eax
subl %edx, %eax
addl %ecx, %eax
jns 0x6124
movq 0x18(%rdi), %r11
imulq %r9, %r11
addq $0xb, %r11
andq %r8, %r11
movq %r11, %rcx
shrq $0x11, %rcx
movl %ecx, %eax
xorl %edx, %edx
idivl %esi
movl %r10d, %eax
subl %edx, %eax
addl %ecx, %eax
js 0x60ff
movq %r11, 0x18(%rdi)
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x11bf(%rip), %rsi      # 0x7301
movq %rax, %rdi
callq 0x2090
movq 0x4e9f(%rip), %rsi      # 0xaff0
movq 0x4e70(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/ServerStorage.cpp
// Function: ServerStorage::setCapacity(int)
void ServerStorage::setCapacity(int total_num_of_buckets) {
  if (this->is_capacity_set) {
    throw std::runtime_error("Capacity of ServerStorage cannot be changed");
  }
  this->is_capacity_set = true;
  this->capacity = total_num_of_buckets;
  this->buckets.assign(total_num_of_buckets, Bucket());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x4f56(%rip)      # 0xb16c
je 0x6266
movq %rdi, %rbx
movb $0x1, 0x4f4a(%rip)      # 0xb16c
movl %esi, 0x8(%rdi)
addq $0x10, %rbx
movslq %esi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x275c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x69ea
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x625c
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x1107(%rip), %rsi      # 0x7381
movq %rax, %rdi
callq 0x2090
movq 0x4d67(%rip), %rsi      # 0xaff0
movq 0x4d38(%rip), %rdx      # 0xafc8
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
jmp 0x62bf
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x62bf
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/obliviousram[P]PathOHeap/src/main.cpp
// Function: main
int main() {
  //Job::run();
  //Job2::run();
  //JobForStatisticalSimulation::run();
  PlainHeapComparisonTest().run();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5b68
movq %rbx, %rdi
callq 0x5c06
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6d12
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6d33
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::Cpu()
Cpu::Cpu() {
    regX = regY = regA = 0x00;
    regPC = mem.read_word(0xFFFC);
    regSP = 0x01ff;
    regP.C = regP.Z = regP.I = regP.D = regP.B = regP.V = regP.N = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x4200
movw $0x0, 0x10020(%rbx)
movb $0x0, 0x10022(%rbx)
movq %r14, %rdi
movl $0xfffc, %esi           # imm = 0xFFFC
callq 0x4380
movw %ax, 0x10024(%rbx)
movw $0x1ff, 0x10026(%rbx)   # imm = 0x1FF
xorl %eax, %eax
movl %eax, 0x10028(%rbx)
movl %eax, 0x1002b(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::ASL_A_execute()
void Cpu::ASL_A_execute() {
    // Arithmetic shift left (Accumulator content)
    // A,Z,C,N = A*2

    uint8_t result = regA << 1;

    regP.Z = result == 0;
    regP.C = (regA >> 7) & 1;
    regP.N = (result >> 7) & 1;

    regA = result;
}

// Assembly:
movb 0x10020(%rdi), %al
movl %eax, %ecx
addb %al, %cl
sete 0x10029(%rdi)
shrb $0x7, %al
movb %al, 0x10028(%rdi)
movl %ecx, %eax
shrb $0x7, %al
movb %al, 0x1002e(%rdi)
movb %cl, 0x10020(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::ASL_mem_execute(unsigned short, unsigned char)
void Cpu::ASL_mem_execute(uint16_t address, uint8_t operand) {
    // Arithmetic shift left (Memory content)
    // M,Z,C,N = M*2

    uint8_t result = operand << 1;

    mem.write_byte(address, result);

    regP.Z = result == 0;
    regP.C = (operand >> 7) & 1;
    regP.N = (result >> 7) & 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
leal (%rbx,%rbx), %eax
addq $0x8, %rdi
movzbl %al, %ebp
movl %ebp, %edx
callq 0x43dc
testb %bpl, %bpl
sete 0x10029(%r14)
shrb $0x7, %bl
movb %bl, 0x10028(%r14)
shrb $0x7, %bpl
movb %bpl, 0x1002e(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::BIT_execute(unsigned char)
void Cpu::BIT_execute(uint8_t operand) {
    // Bit test
    // tmp = A & M, N = tmp[7], V = tmp[6]

    uint8_t tmp =regA & operand;

    regP.Z = tmp == 0;
    regP.V = (tmp >> 6) & 1;
    regP.N = (tmp >> 7) & 1;
}

// Assembly:
andb 0x10020(%rdi), %sil
sete 0x10029(%rdi)
movl %esi, %eax
shrb $0x6, %al
andb $0x1, %al
movb %al, 0x1002d(%rdi)
shrb $0x7, %sil
movb %sil, 0x1002e(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::BRK_execute()
void Cpu::BRK_execute() {
    // Force interrupt

    uint8_t lowPC, highPC;
    lowPC = regPC;
    highPC = (regPC >> 8);
    
    uint8_t procStat;
    procStat =  (regP.N) << 6 |
		(regP.V) << 5 |
		(regP.B) << 4 |
		(regP.D) << 3 |
		(regP.I) << 2 |
		(regP.Z) << 1 |
		(regP.C);
    
    //We push the PC and Processor Status into the stack
    pushStack(highPC);
    pushStack(lowPC);
    pushStack(procStat);

    //We set the PC to the interrupt vector and the Break command
    regPC = mem.read_word(BRK_INT_VECTOR_ADDR);
    regP.B = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzwl 0x10024(%rdi), %ebp
movl %ebp, %edx
shrl $0x8, %edx
movb 0x1002e(%rdi), %al
shlb $0x6, %al
movb 0x1002d(%rdi), %cl
shlb $0x5, %cl
orb %al, %cl
movb 0x1002c(%rdi), %al
shlb $0x4, %al
orb %cl, %al
movb 0x1002b(%rdi), %cl
shlb $0x3, %cl
orb %al, %cl
movb 0x10029(%rdi), %r15b
movb 0x1002a(%rdi), %al
shlb $0x2, %al
orb %cl, %al
addb %r15b, %r15b
orb %al, %r15b
orb 0x10028(%rdi), %r15b
leaq 0x8(%rdi), %r14
movzwl 0x10026(%rdi), %esi
movq %r14, %rdi
callq 0x43dc
movzwl 0x10026(%rbx), %esi
decl %esi
movw %si, 0x10026(%rbx)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movzbl %bpl, %edx
movq %r14, %rdi
callq 0x43dc
movzwl 0x10026(%rbx), %esi
decl %esi
movw %si, 0x10026(%rbx)
andl %r12d, %esi
movzbl %r15b, %edx
movq %r14, %rdi
callq 0x43dc
decw 0x10026(%rbx)
movq %r14, %rdi
movl $0xfffe, %esi           # imm = 0xFFFE
callq 0x4380
movw %ax, 0x10024(%rbx)
movb $0x1, 0x1002c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::DEC_execute(unsigned short, unsigned char)
void Cpu::DEC_execute(uint16_t address, uint8_t operand) {
    //Decrement memory
    //M,Z,N = M-1

    int8_t result = operand-1;
    mem.write_byte(address, result);

    regP.Z = result == 0;
    regP.N = result >> 7;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
decb %dl
addq $0x8, %rdi
movzbl %dl, %ebp
movl %ebp, %edx
callq 0x43dc
testb %bpl, %bpl
sete 0x10029(%rbx)
shrb $0x7, %bpl
movb %bpl, 0x1002e(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::EOR_execute(unsigned char)
void Cpu::EOR_execute(uint8_t operand) {
    //Exclusive OR
    //A,Z,N = A^M

    uint8_t result = regA ^ operand;
    regA = result;

    regP.Z = result == 0;
    regP.N = result >> 7;
}

// Assembly:
movb 0x10020(%rdi), %al
movl %eax, %ecx
xorb %sil, %cl
movb %cl, 0x10020(%rdi)
cmpb %sil, %al
sete 0x10029(%rdi)
shrb $0x7, %cl
movb %cl, 0x1002e(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::INC_execute(unsigned short, unsigned char)
void Cpu::INC_execute(uint16_t address, uint8_t operand) {
    //Increment memory
    //M,Z,N = M+1

    uint8_t result = operand + 1;
    mem.write_byte(address, result);

    regP.Z = result == 0;
    regP.N = result >> 7;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %eax
addq $0x8, %rdi
movzbl %al, %edx
callq 0x43dc
incb %bl
sete 0x10029(%r14)
shrb $0x7, %bl
movb %bl, 0x1002e(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/NGageMegaman[P]NEScutre/src/cpu.cpp
// Function: Cpu::JSR_execute(unsigned short)
void Cpu::JSR_execute(uint16_t address) {
    //Jump to subroutine

    uint16_t returnAddr = regPC - 1; //Last byte of the instruction
    pushStack((returnAddr >> 8) & 0x00ff); //high
    pushStack(returnAddr & 0x00ff); //low
    regPC = address;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl 0x10024(%rdi), %ebx
decl %ebx
movzbl %bh, %edx
leaq 0x8(%rdi), %r15
movzwl 0x10026(%rdi), %esi
movq %r15, %rdi
callq 0x43dc
movzwl 0x10026(%r14), %esi
decl %esi
movw %si, 0x10026(%r14)
andl $0xffff, %esi           # imm = 0xFFFF
movzbl %bl, %edx
movq %r15, %rdi
callq 0x43dc
decw 0x10026(%r14)
movw %bp, 0x10024(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq