LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/include/cnn/Layer.h
// Function: abcdl::cnn::Layer::update_gradient(unsigned long, float)
void update_gradient(const size_t batch_size,
                         const real alpha){
        real learning_rate = alpha / batch_size;
        for(size_t i = 0; i != _weights.size(); i++){
            _weights[i]->operator-=(_batch_weights[i]->operator*(learning_rate));
        }
        if(_bias->get_size() > 0){
            _bias->operator-=(_batch_bias->operator*(learning_rate));
        }

        for(auto& weight : _batch_weights){
            weight->reset();
        }
        _batch_bias->reset();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
js 0x1658c
cvtsi2ss %rsi, %xmm1
jmp 0x165a1
movq %rsi, %rax
shrq %rax
andl $0x1, %esi
orq %rax, %rsi
cvtsi2ss %rsi, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x16606
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq (%rax,%r13,8), %r12
movq 0x98(%rbx), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x210da
movq %r12, %rdi
movq %r14, %rsi
callq 0x20dfc
movq %r14, %rdi
callq 0x18696
incq %r13
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jne 0x165c2
movq 0x58(%rbx), %r14
movq 0x8(%r14), %rax
imulq (%r14), %rax
testq %rax, %rax
je 0x16645
movq 0xb0(%rbx), %rsi
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
callq 0x210da
movq %r14, %rdi
movq %r15, %rsi
callq 0x20dfc
leaq 0x8(%rsp), %rdi
callq 0x18696
movq 0x98(%rbx), %r15
movq 0xa0(%rbx), %r12
cmpq %r12, %r15
je 0x16679
leaq 0x8(%rsp), %r14
movq (%r15), %rdi
movl $0x0, 0x8(%rsp)
movq %r14, %rsi
callq 0x195cc
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1665d
movq 0xb0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
callq 0x195cc
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x166a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18696
movq %rbx, %rdi
callq 0x8500
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/src/framework/Pool.cpp
// Function: abcdl::framework::MaxPooling::pool(abcdl::algebra::Matrix<float>&, abcdl::algebra::Matrix<float> const&, unsigned long, unsigned long, unsigned long)
void MaxPooling::pool(abcdl::algebra::Mat& pool,
                      const abcdl::algebra::Mat& mat,
                      const size_t rows,
                      const size_t cols,
                      const size_t scale){
    real* data = new real[rows * cols];
    for(size_t j = 0; j != rows; j++){
        for(size_t k = 0; k != cols; k++){
            real pooling_value = 0;
            for(size_t m = 0; m != scale; m++){
                for(size_t n = 0; n != scale; n++){
                    real value = mat.get_data(j * scale + m, k * scale + n);
                    if((m == 0 && n == 0) || value > pooling_value){
                        pooling_value = value;
                    }
                }
            }
            data[j * cols + k] = pooling_value;
        }
    }
    pool.set_shallow_data(data, rows, cols);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, 0x20(%rsp)
movq %r8, %rax
imulq %rcx, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x8030
movq %rbx, %rcx
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
testq %r14, %r14
je 0x16c5a
movq %r15, %rsi
xorl %r8d, %r8d
leaq 0x50(%rsp), %rdi
movq $0x0, (%rsp)
movq %rcx, 0x30(%rsp)
movq %r15, 0x28(%rsp)
testq %rcx, %rcx
je 0x16c41
movq (%rsp), %rax
imulq %rcx, %rax
movq 0x10(%rsp), %rdx
leaq (%rdx,%rax,4), %r9
xorl %ebp, %ebp
xorl %r10d, %r10d
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
xorps %xmm0, %xmm0
testq %rsi, %rsi
je 0x16c2c
movq %r8, %r15
xorl %r14d, %r14d
xorl %ebx, %ebx
movaps %xmm0, %xmm1
movq 0x8(%r13), %rax
movq %r15, %r12
imulq %rax, %r12
addq %rbp, %r12
addq %rbx, %r12
imulq (%r13), %rax
cmpq %rax, %r12
jae 0x16bb3
movq 0x10(%r13), %rax
movss (%rax,%r12,4), %xmm0
movq %rbx, %rax
orq %r14, %rax
je 0x16ba6
maxss %xmm1, %xmm0
incq %rbx
movaps %xmm0, %xmm1
cmpq %rbx, %rsi
jne 0x16b75
jmp 0x16c1d
movss %xmm1, 0xc(%rsp)
movq %r10, 0x48(%rsp)
leaq 0x2337f(%rip), %rsi     # 0x39f44
movl $0x44, %edx
movl $0x3, %ecx
callq 0x373d6
movl $0x1f, %edx
leaq 0x50(%rsp), %rdi
leaq 0x23378(%rip), %rsi     # 0x39f5d
callq 0x8350
leaq 0x50(%rsp), %rdi
callq 0x375fe
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %r8
leaq 0x50(%rsp), %rdi
movq 0x38(%rsp), %r9
movq 0x48(%rsp), %r10
movss 0xc(%rsp), %xmm1
jmp 0x16b90
incq %r14
incq %r15
cmpq %rsi, %r14
jne 0x16b70
movss %xmm0, (%r9,%r10,4)
incq %r10
addq %rsi, %rbp
cmpq %rcx, %r10
jne 0x16b5e
movq (%rsp), %rdx
incq %rdx
addq %rsi, %r8
movq %rdx, (%rsp)
cmpq 0x18(%rsp), %rdx
jne 0x16b35
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x18a12
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x375fe
movq %rbx, %rdi
callq 0x8500
nop
// File: /workspace/github_cpp_makefile_star2_O1/sanaa-khan[P]mini-linux-shell/gbsh.cpp
// Function: printWorkingDirectory(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>>>>)
void printWorkingDirectory(vector<string> tokens) {

	int len = 50;
	char cwd[len];

	getcwd(cwd, len);

	if (tokens.size() == 1)
		cout << cwd << "\n";

	// for redirecting output
	else if (tokens[1].size() == 1 and tokens[1][0] == '>') {
		if (tokens.size() == 3) {
			string filename = tokens[2];

			int file_desc = open(filename.c_str(), O_WRONLY | O_CREAT |  O_TRUNC, 0777);
			output = dup(1);

			close(1);
			dup(file_desc);
			close(file_desc);
			
			cout << cwd;
			
			fflush(stdout); 

			dup2(output, 1);
			close(output);
		}

		else if (tokens.size() < 3) {
			cout << "\033[1;31m" << "Error: ";
			cout << "\033[0;38m" << "Output file not provided.\n";
		}

		else {
			cout << "\033[1;31m" << "Error: ";
			cout << "\033[0;38m" << "Too many arguments.\n";
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movl $0x32, %esi
callq 0x20a0
movq (%rbx), %rax
movq 0x8(%rbx), %r14
subq %rax, %r14
cmpq $0x20, %r14
jne 0x3085
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2090
movq 0x3f6a(%rip), %r14      # 0x6fc8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21b0
leaq 0x20d6(%rip), %rsi      # 0x5149
movl $0x1, %edx
movq %r14, %rdi
callq 0x21b0
jmp 0x3163
cmpq $0x1, 0x28(%rax)
jne 0x3163
movq 0x20(%rax), %rcx
cmpb $0x3e, (%rcx)
jne 0x3163
cmpq $0x60, %r14
jne 0x316b
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x454e
movq (%rbx), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x20e0
movl %eax, %ebx
movl $0x1, %edi
callq 0x2280
movl %eax, 0x40cc(%rip)      # 0x71b8
movl $0x1, %edi
callq 0x2320
movl %ebx, %edi
callq 0x2280
movl %ebx, %edi
callq 0x2320
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2090
movq 0x3eb0(%rip), %rdi      # 0x6fc8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21b0
movq 0x3e7e(%rip), %rax      # 0x6fa8
movq (%rax), %rdi
callq 0x21c0
movl 0x4080(%rip), %edi      # 0x71b8
movl $0x1, %esi
callq 0x2150
movl 0x4070(%rip), %edi      # 0x71b8
callq 0x2320
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3163
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x3e56(%rip), %rbx      # 0x6fc8
leaq 0x1f08(%rip), %rsi      # 0x5081
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x1efc(%rip), %rsi      # 0x5089
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21b0
leaq 0x1ef0(%rip), %rsi      # 0x5091
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21b0
movq 0x3e13(%rip), %rdi      # 0x6fc8
cmpq $0x40, %r14
ja 0x31cc
leaq 0x1ed7(%rip), %rsi      # 0x5099
movl $0x1a, %edx
jmp 0x307b
leaq 0x1ee3(%rip), %rsi      # 0x50b6
movl $0x14, %edx
jmp 0x307b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x31f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/sanaa-khan[P]mini-linux-shell/gbsh.cpp
// Function: changeDirectory(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>>>>)
void changeDirectory(vector<string> tokens) {

	string temp;

	if (tokens.size() > 1)
		temp = tokens[1];
	else
		temp = "/home";

	if (tokens.size() > 3) {
		cout << "\033[1;31m" << "Error: ";
		cout << "\033[0;38m" << "Too many arguments.\n";
		return;
	}

	const char* path = temp.c_str();

	chdir(path);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
cmpq $0x21, %rax
jb 0x323d
addq $0x20, %rsi
leaq 0x8(%rsp), %rdi
callq 0x20c0
jmp 0x3258
leaq 0x1e9a(%rip), %rcx      # 0x50de
leaq 0x8(%rsp), %rdi
movl $0x5, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x22b0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x61, %rax
jb 0x32c7
movq 0x3d5c(%rip), %rdi      # 0x6fc8
leaq 0x1e0e(%rip), %rsi      # 0x5081
movl $0x7, %edx
callq 0x21b0
movq 0x3d44(%rip), %rdi      # 0x6fc8
leaq 0x1dfe(%rip), %rsi      # 0x5089
movl $0x7, %edx
callq 0x21b0
movq 0x3d2c(%rip), %rdi      # 0x6fc8
leaq 0x1dee(%rip), %rsi      # 0x5091
movl $0x7, %edx
callq 0x21b0
movq 0x3d14(%rip), %rdi      # 0x6fc8
leaq 0x1dfb(%rip), %rsi      # 0x50b6
movl $0x14, %edx
callq 0x21b0
jmp 0x32d1
movq 0x8(%rsp), %rdi
callq 0x2240
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x32e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x330a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/sanaa-khan[P]mini-linux-shell/gbsh.cpp
// Function: unsetEnvVar(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>>>>)
void unsetEnvVar(vector<string> tokens) {

	char cwd[100];
	getcwd(cwd, 100);

	setenv("SHELL", cwd, 1);

	string name;

	if (tokens.size() == 1) {
		cout << "\033[1;31m" << "Error: ";
		cout << "\033[0;38m" << "Name of environment variable not given.\n";
		return;
	}

	if (tokens.size() == 2)
		name = tokens[1];

	else {
		cout << "\033[1;31m" << "Error: ";
		cout << "\033[0;38m" << "Too many arguments provided.\n";
		return;
	}

	char* var = getenv(name.c_str());

	if (var == NULL)
		cout << "'" << name << "' is undefined.\n";

	else
		unsetenv(name.c_str());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x64, %esi
movq %r14, %rdi
callq 0x20a0
leaq 0x185a(%rip), %rdi      # 0x5069
movq %r14, %rsi
movl $0x1, %edx
callq 0x2270
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq $0x2, %rax
je 0x38a5
cmpq $0x1, %rax
jne 0x38d0
movq 0x3772(%rip), %rdi      # 0x6fc8
leaq 0x1824(%rip), %rsi      # 0x5081
movl $0x7, %edx
callq 0x21b0
movq 0x375a(%rip), %rdi      # 0x6fc8
leaq 0x1814(%rip), %rsi      # 0x5089
movl $0x7, %edx
callq 0x21b0
movq 0x3742(%rip), %rdi      # 0x6fc8
leaq 0x1804(%rip), %rsi      # 0x5091
movl $0x7, %edx
callq 0x21b0
movl $0x28, %edx
leaq 0x1861(%rip), %rsi      # 0x5104
jmp 0x3924
addq $0x20, %rsi
movq %rsp, %rdi
callq 0x20c0
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x21f0
testq %rax, %rax
je 0x3951
movq %rbx, %rdi
callq 0x2220
jmp 0x3930
movq 0x36f1(%rip), %rdi      # 0x6fc8
leaq 0x17a3(%rip), %rsi      # 0x5081
movl $0x7, %edx
callq 0x21b0
movq 0x36d9(%rip), %rdi      # 0x6fc8
leaq 0x1793(%rip), %rsi      # 0x5089
movl $0x7, %edx
callq 0x21b0
movq 0x36c1(%rip), %rdi      # 0x6fc8
leaq 0x1783(%rip), %rsi      # 0x5091
movl $0x7, %edx
callq 0x21b0
movl $0x1d, %edx
leaq 0x1809(%rip), %rsi      # 0x512d
movq 0x369d(%rip), %rdi      # 0x6fc8
callq 0x21b0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3946
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq 0x3670(%rip), %rdi      # 0x6fc8
leaq 0x17ec(%rip), %rsi      # 0x514b
movl $0x1, %edx
callq 0x21b0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x364f(%rip), %rdi      # 0x6fc8
callq 0x21b0
leaq 0x17df(%rip), %rsi      # 0x5164
movl $0x10, %edx
movq %rax, %rdi
callq 0x21b0
jmp 0x3930
jmp 0x3996
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x39af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/utils.cpp
// Function: words(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> words(const string &str) {
    vector<string> v;
    int start_pos = 0;
    bool in_word = false;

    for (size_t i = 0; i < str.size(); i++) {
        if (str[i] == ' ' || str[i] == '\n' || str[i] == '\t') {
            if (!in_word)
                continue;
            in_word = false;
            v.push_back(str.substr(start_pos, i - start_pos));
            continue;
        }

        if (in_word)
            continue;

        in_word = true;
        start_pos = i;
    }

    if (in_word) {
        v.push_back(str.substr(start_pos, str.size() - start_pos));
    }

    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rcx
xorl %r15d, %r15d
testq %rcx, %rcx
je 0x3a3b
movabsq $0x100000600, %rbp      # imm = 0x100000600
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
xorl %eax, %eax
movq (%r14), %rcx
movzbl (%rcx,%r13), %ecx
cmpq $0x20, %rcx
ja 0x3a19
btq %rcx, %rbp
jae 0x3a19
testb $0x1, %al
je 0x3a2a
movslq %r15d, %rdx
movq %r13, %rcx
subq %rdx, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x32c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4004
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a15
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
xorl %eax, %eax
jmp 0x3a2a
testb $0x1, %al
cmovel %r13d, %r15d
movzbl %al, %eax
movl $0x1, %ecx
cmovel %ecx, %eax
incq %r13
movq 0x8(%r14), %rcx
cmpq %rcx, %r13
jb 0x39c2
movslq %r15d, %r15
jmp 0x3a3d
xorl %eax, %eax
testb $0x1, %al
je 0x3a7c
subq %r15, %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4004
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a7c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x3ab0
jmp 0x3a9e
movq %rax, %r14
jmp 0x3ac2
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3ac2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3fa8
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/utils.cpp
// Function: cat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void cat(string filename) {
    ifstream ifs(filename);
    string str;
    while (getline(ifs, str))
        cout << str << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rsi
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x33c0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x8(%rsp), %r14
movq 0xe4b7(%rip), %r15      # 0x11fd0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3440
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq 0x8(%rsp), %rsi
jne 0x3b89
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x32f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31c0
jmp 0x3b19
cmpq %r13, %rsi
je 0x3ba1
movq 0x18(%rsp), %rax
incq %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x32a0
leaq 0x28(%rsp), %rdi
callq 0x3090
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3bd6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x28(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/utils.cpp
// Function: crc32(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned int crc32(string str) {
    unsigned int crcinit = 0;
    unsigned int crc = 0;

    crc = crcinit ^ 0xFFFFFFFF;
    for (size_t i = 0; i < str.size(); i++) {
        crc = ((crc >> 8) & 0x00FFFFFF) ^ crc32tab[(crc ^ (str[i])) & 0xFF];
    }
    return crc ^ 0xFFFFFFFF;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x3fa5
movq (%rdi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
leaq 0x812b(%rip), %rdi      # 0xc0b0
movl %eax, %r8d
shrl $0x8, %r8d
xorb (%rdx,%rsi), %al
movzbl %al, %r9d
movl %r8d, %eax
xorl (%rdi,%r9,4), %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x3f85
notl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Transaction::begin()
void Transaction::begin() {
    TXLOG;
    unique_lock<mutex> lock(giant_mtx_);
    lock_ = move(lock);
    wait();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x818e(%rip), %rdi      # 0xc4c0
leaq 0x7d21(%rip), %rdx      # 0xc05a
movl $0x20, %ecx
xorl %eax, %eax
callq 0x3060
leaq 0xdf24(%rip), %rax      # 0x12270
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x84da
movb $0x1, 0x8(%r14)
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x736a
movq %rbx, %rdi
callq 0x438e
movq %r14, %rdi
callq 0x73d4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Transaction::commit()
void Transaction::commit() {
    TXLOG;
    db_->apply_tx(this);
    for (const auto& key : write_log_) {
        scheduler_->log(id_, key, Write);
    }
    finish();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x80d1(%rip), %rdi      # 0xc4c0
leaq 0x7c7d(%rip), %rdx      # 0xc073
movl $0x27, %ecx
xorl %eax, %eax
callq 0x3060
movq 0xd8(%rbx), %rdi
movq %rbx, %rsi
callq 0x44d8
movq 0x78(%rbx), %rbp
movq 0x80(%rbx), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %rbp
je 0x449f
leaq 0x28(%rsp), %r12
leaq 0x18(%rsp), %r14
movl 0x74(%rbx), %r15d
movq 0xe0(%rbx), %r13
movl $0x98, %ecx
addq %rcx, %r13
movq %r12, 0x18(%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x840a
movl %r15d, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
movq %r13, %rdi
leaq 0xc(%rsp), %rsi
movq %r14, %rdx
leaq 0x8(%rsp), %rcx
callq 0x7a72
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x4494
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32a0
addq $0x20, %rbp
cmpq 0x10(%rsp), %rbp
jne 0x4430
movq %rbx, %rdi
callq 0x45f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x44d0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: DataBase::apply_tx(Transaction*)
void DataBase::apply_tx(Transaction* tx) {
    string buf = serialize(tx->write_set);
    size_t nbytes_written = 0;
    while (nbytes_written < buf.size()) {
        nbytes_written += write(fd_log_,
                buf.c_str() + nbytes_written,
                buf.size() - nbytes_written);
    }
    fsync(fd_log_);

    // apply write_set to table
    for (const auto& [key, value] : tx->write_set) {
        if (value.first == New)
            table[key].value = value.second;
        else
            table.erase(key);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x803e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x623c
leaq 0x28(%rsp), %rdi
callq 0x7fc6
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x453d
xorl %r15d, %r15d
movl 0x78(%r14), %edi
movq 0x8(%rsp), %rsi
addq %r15, %rsi
subq %r15, %rdx
callq 0x30f0
addq %rax, %r15
movq 0x10(%rsp), %rdx
cmpq %rdx, %r15
jb 0x451c
movl 0x78(%r14), %edi
callq 0x3240
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x4591
leaq 0x20(%r15), %rsi
cmpl $0x0, 0x40(%r15)
je 0x4573
movq %r14, %rdi
callq 0x9716
movq %r14, %rdi
movq %rax, %rsi
callq 0x97be
jmp 0x4581
movl 0x44(%r15), %ebp
movq %r14, %rdi
callq 0x74a4
movl %ebp, (%rax)
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %rbx, %rax
jne 0x4553
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45ca
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7fc6
jmp 0x45e8
jmp 0x45ca
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Transaction::finish()
void Transaction::finish() {
    for (const auto& entry : write_set) {
        Key key = entry.first;
        db_->table[key].nlock = 0;
    }
    for (const auto& key : lock_set) {
        db_->table[key].nlock = 0;
    }
    write_set = {};
    is_done = true;
    turn_ = false;
    lock_.unlock();
    scheduler_->notify();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r13
cmpq %r13, %r14
je 0x466d
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x840a
movq 0xd8(%rbx), %rdi
movq %r15, %rsi
callq 0x74a4
movl $0x0, 0x4(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x465d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %r14, %rdi
callq 0x31d0
movq %rax, %r14
cmpq %r13, %rax
jne 0x4618
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r15
cmpq %r15, %r14
je 0x4696
movq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x74a4
movl $0x0, 0x4(%rax)
addq $0x20, %r14
jmp 0x4675
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8ec2
movb $0x1, %bpl
movb %bpl, 0x48(%rbx)
movb $0x0, 0x70(%rbx)
leaq 0x90(%rbx), %rdi
callq 0x7520
movq 0xe0(%rbx), %rdi
movb %bpl, 0x50(%rdi)
addq $0x58, %rdi
callq 0x3140
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x46f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Transaction::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool Transaction::set(Key key, int val) {
    TXLOG;

    if (db_->table.count(key) > 0) {
        while (!db_->get_lock(this, key, Write)) {
            wait();
        }
    }
    write_log_.push_back(key);
    write_set[key] = make_pair(New, val);
    wait();
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x7d78(%rip), %rdi      # 0xc4c0
leaq 0x78b5(%rip), %rdx      # 0xc004
movl $0x35, %ecx
xorl %eax, %eax
callq 0x3060
movq 0xd8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8516
addq $0x8, %r15
cmpq %r15, %rax
je 0x47da
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0xd8(%rbx), %r12
movq %r13, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x840a
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x4836
movl %eax, %r12d
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x47cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
testb %r12b, %r12b
jne 0x47da
movq %rbx, %rdi
callq 0x438e
jmp 0x4780
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x73ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7428
movl $0x0, (%rax)
movl %ebp, 0x4(%rax)
movq %rbx, %rdi
callq 0x438e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x482d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: DataBase::get_lock(Transaction*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, BaseOp)
bool DataBase::get_lock(Transaction* tx, Key key, BaseOp locktype) {
    if (table.count(key) <= 0) {
        UNREACHABLE;
        return false;
    }

    if (vexists(tx->lock_set, key)) {
        return ((locktype == Write && table[key].nlock == -1) ||
                (locktype == Read && table[key].nlock > 0));
    }

    if (locktype == Write) {
        if (table[key].nlock != 0)
            return false;
        table[key].nlock = -1;
        tx->lock_set.push_back(key);
        return true;
    }

    if (table[key].nlock < 0)
        return false;

    table[key].nlock++;
    tx->lock_set.push_back(key);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x8516
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x4993
movl %ebp, 0xc(%rsp)
addq $0x30, %r15
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x76e6
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0x840a
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %rbp
movq %r13, 0x18(%rsp)
cmpq %rbp, %r12
je 0x48e2
movq %r14, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x98a8
movzbl %al, %eax
addq %rax, %r14
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x48ba
testq %r14, %r14
setne %bpl
movq 0x10(%rsp), %r14
jmp 0x48e4
xorl %ebp, %ebp
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x4900
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x20(%rsp), %rdi
callq 0x3fa8
testb %bpl, %bpl
je 0x4945
movl 0xc(%rsp), %ebp
testl %ebp, %ebp
je 0x4931
cmpl $0x1, %ebp
jne 0x4998
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74a4
cmpl $-0x1, 0x4(%rax)
je 0x498f
testl %ebp, %ebp
jne 0x4998
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74a4
cmpl $0x0, 0x4(%rax)
setg %al
jmp 0x499a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74a4
movl 0x4(%rax), %eax
cmpl $0x1, 0xc(%rsp)
jne 0x4972
testl %eax, %eax
jne 0x4998
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74a4
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
jmp 0x4984
testl %eax, %eax
js 0x4998
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74a4
incl 0x4(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x73ea
movb $0x1, %al
jmp 0x499a
callq 0x34b1
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3fa8
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Transaction::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Transaction::del(Key key) {
    TXLOG;

    if (!has_key(key)) {
        return true;
    }
    while (!db_->get_lock(this, key, Write)) {
        wait();
    }
    write_log_.push_back(key);
    write_set[key] = make_pair(Delete, 0);
    wait();
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x77fc(%rip), %rdi      # 0xc4c0
leaq 0x738b(%rip), %rdx      # 0xc056
movl $0x60, %ecx
xorl %eax, %eax
callq 0x3060
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x840a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c56
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4d1b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
testb %bpl, %bpl
je 0x4dae
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0xd8(%rbx), %r12
movq %r13, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x840a
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x4836
movl %eax, %r12d
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4d79
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
testb %r12b, %r12b
jne 0x4d88
movq %rbx, %rdi
callq 0x438e
jmp 0x4d2e
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x73ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7428
movq $0x1, (%rax)
movq %rbx, %rdi
callq 0x438e
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x4dd5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4de6
movq (%r13), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Transaction::keys[abi:cxx11]()
vector<string> Transaction::keys() {
    TXLOG;

    vector<string> v;
    for (const auto& entry : db_->table) {
        Key key = entry.first;
        if (write_set.count(key) > 0 && write_set[key].first == Delete)
            continue;
        v.push_back(key);
    }
    for (const auto& [key, val] : write_set) {
        if (db_->table.count(key) <= 0 || val.first == Delete)
            continue;
        v.push_back(key);
    }

    wait();
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rsi), %esi
leaq 0x76b4(%rip), %rdi      # 0xc4c0
leaq 0x726d(%rip), %rdx      # 0xc080
movl $0x6f, %ecx
xorl %eax, %eax
callq 0x3060
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, (%rsp)
movq $0x0, 0x10(%rbx)
movq 0xd8(%r14), %r13
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r13, %r15
je 0x4ebe
leaq 0x18(%rsp), %rbp
leaq 0x8(%r14), %rbx
leaq 0x8(%rsp), %r12
movq %rbp, 0x8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x840a
movq %r14, %rdi
movq %r12, %rsi
callq 0x8ada
cmpq %rbx, %rax
je 0x4e8b
movq %r14, %rdi
movq %r12, %rsi
callq 0x7428
cmpl $0x1, (%rax)
je 0x4e97
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x73ea
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4eae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %r13, %rax
jne 0x4e53
movq 0x18(%r14), %r15
leaq 0x8(%r14), %rbx
cmpq %rbx, %r15
je 0x4f0d
leaq 0x20(%r15), %r12
movq 0xd8(%r14), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x8516
addq $0x8, %r13
cmpq %r13, %rax
je 0x4efd
cmpl $0x1, 0x40(%r15)
je 0x4efd
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x73ea
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %rbx, %rax
jne 0x4ecb
movq %r14, %rdi
callq 0x438e
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f2a
movq %rax, %r14
jmp 0x4f49
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq (%rsp), %rdi
callq 0x3fa8
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Transaction::get_until_success(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Transaction::get_until_success(Key key) {
    TXLOG;
    optional<int> tmp = get(key);
    while (!tmp.has_value()) {
        wait();
        tmp = get(key);
    }
    wait();
    return tmp.value();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x74(%rdi), %esi
leaq 0x7548(%rip), %rdi      # 0xc4c0
leaq 0x7577(%rip), %rdx      # 0xc4f6
movl $0x83, %ecx
xorl %eax, %eax
callq 0x3060
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x840a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49be
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4fd0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
btq $0x20, %r15
jb 0x5034
movabsq $0x100000000, %rbp      # imm = 0x100000000
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
callq 0x438e
movq %r13, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x840a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x49be
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x502f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
testq %rbp, %r15
je 0x4feb
movq %rbx, %rdi
callq 0x438e
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x5060
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5071
movq (%r13), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: ConflictGraph::emit()
void ConflictGraph::emit() {
    FILE* fp_out = fopen(graphfilename_.c_str(), "w");

    vector<int> serial_schedule = serialize();

    fprintf(fp_out, "/*\n");
    fprintf(fp_out, "serial schedule:\n");
    for (const auto& n : serial_schedule) {
        fprintf(fp_out, "%d\n", n);
    }
    fprintf(fp_out, " */\n");

    fprintf(fp_out, "digraph g {\n");
    for (const auto& n : nodes_) {
        fprintf(fp_out, "    Tx%d;\n", n);
    }
    for (const auto& e : edges_) {
        string conflict_type =
            (e.type == ReadWrite) ? "r-w" :
            (e.type == WriteRead) ? "w-r" : "w-w";
        fprintf(fp_out, "    Tx%d -> Tx%d [label = \"%s\"];\n",
                e.from, e.to, conflict_type.c_str());
    }
    fprintf(fp_out, "}\n");
    fclose(fp_out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rdi
leaq 0x7449(%rip), %rsi      # 0xc599
callq 0x3320
movq %rax, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7010
leaq 0x73f7(%rip), %rdi      # 0xc564
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
leaq 0x73e2(%rip), %rdi      # 0xc568
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
movq (%r15), %r12
movq 0x8(%r15), %r13
cmpq %r13, %r12
je 0x51c5
leaq 0x7370(%rip), %r15      # 0xc51b
movl (%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3370
addq $0x4, %r12
cmpq %r13, %r12
jne 0x51ab
leaq 0x73ae(%rip), %rdi      # 0xc57a
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
leaq 0x739a(%rip), %rdi      # 0xc57f
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x5224
leaq 0x7382(%rip), %r15      # 0xc58c
movl (%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3370
addq $0x4, %r12
cmpq %r13, %r12
jne 0x520a
movq 0x18(%r14), %r12
movq 0x20(%r14), %r13
cmpq %r13, %r12
je 0x52b7
leaq 0x28(%rsp), %rbp
leaq 0x18(%rsp), %r14
leaq 0x735d(%rip), %r15      # 0xc5a3
movl 0x8(%r12), %eax
leaq 0x7349(%rip), %rsi      # 0xc59b
cmpl $0x1, %eax
je 0x525e
leaq 0x7341(%rip), %rsi      # 0xc59f
testl %eax, %eax
leaq 0x7330(%rip), %rax      # 0xc597
cmoveq %rax, %rsi
movq %rbp, 0x18(%rsp)
leaq 0x3(%rsi), %rdx
movq %r14, %rdi
callq 0x98da
movl (%r12), %edx
movl 0x4(%r12), %ecx
movq 0x18(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3370
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x52ae
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32a0
addq $0xc, %r12
cmpq %r13, %r12
jne 0x5246
leaq 0x728f(%rip), %rdi      # 0xc54d
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3470
movq %rbx, %rdi
callq 0x3280
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x52ee
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5316
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Scheduler::add_tx(std::function<void (Transaction*)>)
void Scheduler::add_tx(Transaction::Logic logic) {
    LOG;
    // create transaction objects and store it
    unique_ptr<Transaction> tx = db_->generate_tx(move(logic));
    transactions.push(move(tx));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x71d6(%rip), %rdi      # 0xc508
leaq 0x71e6(%rip), %rsi      # 0xc51f
movl $0xb1, %edx
xorl %eax, %eax
callq 0x3060
movq 0xb0(%rbx), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x18(%r14), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x5385
movups (%r14), %xmm1
addq $0x10, %r14
movaps %xmm1, 0x10(%rsp)
movq %rax, 0x20(%rsp)
movups %xmm0, (%r14)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5426
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x53ad
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9222
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x53ce
leaq 0x8(%rsp), %rdi
callq 0x91a8
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x541e
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x53ef
leaq 0x8(%rsp), %rdi
callq 0x91a8
movq $0x0, 0x8(%rsp)
jmp 0x5416
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x5416
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x75e4
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: Scheduler::start()
void Scheduler::start() {
    // spawn transaction threads
    unique_lock<mutex> lock(giant_mtx_);
    lock_ = move(lock);
    LOG;
    for (const auto& tx : transactions) {
        thread th(tx->logic, tx.get());
        tx->set_thread(move(th));
    }
    run();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xcd84(%rip), %rax      # 0x12270
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x84da
movb $0x1, 0x8(%r14)
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x736a
leaq 0x6fec(%rip), %rdi      # 0xc508
leaq 0x7003(%rip), %rsi      # 0xc526
movl $0xbb, %edx
xorl %eax, %eax
callq 0x3060
movq 0x10(%rbx), %r13
movq %rbx, (%rsp)
movq 0x30(%rbx), %r12
cmpq %r12, %r13
je 0x55a9
movq (%rsp), %rax
movq 0x20(%rax), %rbx
movq 0x28(%rax), %rbp
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq (%r13), %rsi
addq $0x50, %rsi
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x764c
movq (%r13), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x55cb
movq 0x10(%rsp), %rcx
movq %rcx, 0xd0(%rax)
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x55a4
movq 0x8(%rbp), %r13
addq $0x8, %rbp
leaq 0x200(%r13), %rbx
cmpq %r12, %r13
jne 0x5556
movq (%rsp), %rdi
callq 0x55e8
leaq 0x18(%rsp), %rdi
callq 0x73d4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x30a0
jmp 0x55d2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x73d4
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: DataBase::~DataBase()
DataBase::~DataBase() {
    LOG;

    // checkpointing
    ofstream ofs_dump(dumpfilename_);  // dump file will be truncated
    for (const auto& [key, v] : table) {
        ofs_dump << key << " " << v.value << endl;
    }

    ofs_dump.close();
    close(fd_log_);

    // clear log file
    fd_log_ = open(logfilename_.c_str(), O_TRUNC);
    close(fd_log_);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x680f(%rip), %rdi      # 0xc508
leaq 0x682c(%rip), %rsi      # 0xc52c
movl $0xf9, %edx
xorl %eax, %eax
callq 0x3060
leaq 0x38(%rbx), %rsi
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x3460
movq 0x18(%rbx), %r14
leaq 0x8(%rbx), %rbp
cmpq %rbp, %r14
je 0x5da1
leaq 0x8(%rsp), %r15
leaq 0x67fe(%rip), %r12      # 0xc536
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x32f0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32f0
movl 0x40(%r14), %esi
movq %r13, %rdi
callq 0x3400
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3270
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x31d0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x5d38
leaq 0x8(%rsp), %rdi
callq 0x3360
movl 0x78(%rbx), %edi
callq 0x3480
movq 0x58(%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x31f0
movl %eax, 0x78(%rbx)
movl %eax, %edi
callq 0x3480
movq 0xc1f4(%rip), %rax      # 0x11fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x3230
leaq 0x100(%rsp), %rdi
callq 0x30e0
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x5e17
movq (%rax), %rsi
incq %rsi
callq 0x32a0
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x5e2f
movq (%rax), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x7f4e
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e4b
movq %rax, %rdi
callq 0x75e4
nop
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/database.cpp
// Function: DataBase::serialize(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<ChangeMode, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::pair<ChangeMode, int>>>>)
string DataBase::serialize(DBDiff diff) {
    string buf = "{\n";
    for (const auto& [key, value] : diff) {
        buf += make_log_format(value.first, key, value.second);
    }
    buf += "}\n";
    return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x6327(%rip), %rsi      # 0xc589
leaq 0x6322(%rip), %rdx      # 0xc58b
callq 0x98da
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x6311
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %r12
movl 0x40(%r15), %ebp
movq %r13, 0x28(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x840a
movl 0x44(%r15), %r8d
leaq 0x8(%rsp), %rdi
movl %ebp, %edx
movq %r12, %rcx
callq 0x6394
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x30d0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x62e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x62fd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
cmpq %r14, %rax
jne 0x6289
leaq 0x6235(%rip), %rsi      # 0xc54d
movq %rbx, %rdi
callq 0x3450
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6334
movq %rax, %r14
jmp 0x6374
movq %rax, %r14
jmp 0x635d
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x635d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6374
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x638c
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32a0
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/main.cpp
// Function: transaction1(Transaction*)
void transaction1(Transaction* tx) {
    tx->begin();
    tx->set("key1", 1);
    tx->set("key2", 2);
    tx->commit();
    // vector<string> keys = tx->keys();
    // for (const auto& key : keys)
    //     cout << key << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x431e
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c37(%rip), %rsi      # 0xc7a0
leaq 0x1c34(%rip), %rdx      # 0xc7a4
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x98da
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4728
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xaba4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bf1(%rip), %rsi      # 0xc7a5
leaq 0x1bee(%rip), %rdx      # 0xc7a9
movq %rsp, %r14
movq %r14, %rdi
callq 0x98da
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x4728
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xabec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x43d4
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xac0f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xac1f
movq (%r15), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/main.cpp
// Function: transaction4(Transaction*)
void transaction4(Transaction* tx) {
    tx->begin();
    int x = tx->get_until_success("key1");
    tx->set("key2", x + 10);
    tx->commit();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x431e
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a3f(%rip), %rsi      # 0xc7a0
leaq 0x1a3c(%rip), %rdx      # 0xc7a4
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x98da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f5a
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xad99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19fc(%rip), %rsi      # 0xc7a5
leaq 0x19f9(%rip), %rdx      # 0xc7a9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x98da
addl $0xa, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4728
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xade4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x43d4
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xae09
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xae19
movq (%r15), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/momohatt[P]seccampDB/main.cpp
// Function: transaction5(Transaction*)
void transaction5(Transaction* tx) {
    tx->begin();
    int x = tx->get_until_success("key2");
    tx->set("key1", x + 1);
    tx->commit();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x431e
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1962(%rip), %rsi      # 0xc7a5
leaq 0x195f(%rip), %rdx      # 0xc7a9
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x98da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f5a
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xae7b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32a0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1915(%rip), %rsi      # 0xc7a0
leaq 0x1912(%rip), %rdx      # 0xc7a4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x98da
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4728
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xaec5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x43d4
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xaeea
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xaefa
movq (%r15), %rsi
incq %rsi
callq 0x32a0
movq %rbx, %rdi
callq 0x3410