LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: btbujiangjun[P]abcdl/src/cnn/CNN.cpp
// Function: abcdl::cnn::CNN::evaluate(abcdl::algebra::MatrixSet<float> const&, abcdl::algebra::MatrixSet<float> const&)
size_t CNN::evaluate(const abcdl::algebra::MatSet& data_mat, const abcdl::algebra::MatSet& label_mat){
    size_t cnt = 0;
    size_t size = data_mat.size();
    for(size_t i = 0; i != size; i++){
        forward(data_mat[i]);
        if(label_mat[i].argmax() == _layers[_layers.size() - 1]->get_activation(0).argmax()){
            cnt++;
        }
    }
    return cnt;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x2c560
movq %rax, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
cmpq 0xa0(%rsp), %rax
je 0x2c1dc
movq 0xb8(%rsp), %rsi
movq 0x98(%rsp), %rdx
leaq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2c640
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2bd00
jmp 0x2c0df
leaq 0x70(%rsp), %rdi
callq 0x30940
movq 0xb0(%rsp), %rsi
movq 0x98(%rsp), %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2c640
movq 0x18(%rsp), %rdi
callq 0x59e50
movq %rax, 0x20(%rsp)
jmp 0x2c119
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
callq 0x26160
movq 0x8(%rsp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x2c440
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29aa0
movq %rax, 0x10(%rsp)
jmp 0x2c14f
movq 0x10(%rsp), %rdi
callq 0x59e50
movq %rax, (%rsp)
jmp 0x2c15f
leaq 0x38(%rsp), %rdi
callq 0x30940
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jne 0x2c1c1
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x2c1c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x30940
jmp 0x2c1ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x30940
jmp 0x2c1ec
jmp 0x2c1c3
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x2c099
movq 0xa8(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x95d0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movss %xmm0, 0xd4(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x28(%rsp)
movss 0xd4(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x38(%rsp)
testq %rax, %rax
movss %xmm0, 0x3c(%rsp)
js 0x2ca0d
movss 0x38(%rsp), %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x34(%rsp), %xmm0
movss 0x3c(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0xd0(%rsp)
movq $0x0, 0xc8(%rsp)
movq 0x28(%rsp), %rdi
movq 0xc8(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x40, %rdi
callq 0x2a8a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
je 0x2cb0f
movq 0x28(%rsp), %rdi
addq $0x40, %rdi
movq 0xc8(%rsp), %rsi
callq 0x2cfe0
movq 0x28(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x98, %rdi
movq 0xc8(%rsp), %rsi
callq 0x2a850
movq (%rax), %rsi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0xd0(%rsp), %rdx
callq 0x40c00
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x40830
jmp 0x2cac3
leaq 0xa0(%rsp), %rdi
callq 0x30940
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc8(%rsp)
jmp 0x2ca32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x30940
jmp 0x2cc2d
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x2a510
cmpq $0x0, %rax
jbe 0x2cb8d
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rcx
movq %rcx, (%rsp)
movq 0xb0(%rax), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xd0(%rsp), %rdx
callq 0x40c00
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x40830
jmp 0x2cb5e
leaq 0x68(%rsp), %rdi
callq 0x30940
jmp 0x2cb8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x30940
jmp 0x2cc2d
movq 0x28(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x173b0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x173e0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x17410
testb $0x1, %al
jne 0x2cbd0
jmp 0x2cc06
leaq 0x58(%rsp), %rdi
callq 0x17450
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rdi
xorps %xmm0, %xmm0
movss %xmm0, 0x44(%rsp)
leaq 0x44(%rsp), %rsi
callq 0x31ef0
leaq 0x58(%rsp), %rdi
callq 0x17460
jmp 0x2cbbb
movq 0x28(%rsp), %rax
movq 0xb0(%rax), %rdi
xorps %xmm0, %xmm0
movss %xmm0, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x31ef0
addq $0xe8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x95d0
nopw (%rax,%rax)
// File: btbujiangjun[P]abcdl/src/framework/Pool.cpp
// Function: abcdl::framework::MeanPooling::pool(abcdl::algebra::Matrix<float>&, abcdl::algebra::Matrix<float> const&, unsigned long, unsigned long, unsigned long)
void MeanPooling::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];
    size_t pooling_size = scale * scale;
    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++){
                    pooling_value += mat.get_data(j * scale + m, k * scale + n);
                }
            }
            data[j * cols + k] = pooling_value / pooling_size;
        }
    }
    pool.set_shallow_data(data, rows, cols);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x58(%rsp), %rax
imulq 0x50(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
imulq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x2dbd0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x2dbbb
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x2db34
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x2db22
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
imulq 0x48(%rsp), %rsi
addq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
imulq 0x48(%rsp), %rdx
addq 0x10(%rsp), %rdx
callq 0x2a0c0
movss (%rax), %xmm0
addss 0x24(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2dacc
jmp 0x2db24
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2dab7
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x38(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x8(%rsp)
testq %rax, %rax
movss %xmm0, 0xc(%rsp)
js 0x2db7e
movss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x4(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
divss %xmm1, %xmm0
movq 0x40(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x50(%rsp), %rcx
addq 0x28(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2da95
jmp 0x2dbbd
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2da7c
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x30ce0
addq $0x78, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x48(%rsp), %rax
imulq 0x40(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x2dd78
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x2dd63
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x2dd30
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x2dd1b
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
imulq 0x38(%rsp), %rsi
addq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
imulq 0x38(%rsp), %rdx
addq 0x8(%rsp), %rdx
callq 0x2a0c0
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2dcf0
cmpq $0x0, 0x8(%rsp)
je 0x2dcfd
movss 0x4(%rsp), %xmm0
ucomiss 0x1c(%rsp), %xmm0
jbe 0x2dd09
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
jmp 0x2dd0b
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2dca0
jmp 0x2dd1d
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2dc87
movss 0x1c(%rsp), %xmm0
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
imulq 0x40(%rsp), %rcx
addq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2dc65
jmp 0x2dd65
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2dc4c
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x30ce0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: btbujiangjun[P]abcdl/src/framework/Pool.cpp
// Function: abcdl::framework::L2Pooling::pool(abcdl::algebra::Matrix<float>&, abcdl::algebra::Matrix<float> const&, unsigned long, unsigned long, unsigned long)
void L2Pooling::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(value != 0){
                        pooling_value += (value * value);
                    }
                }
            }
            data[j * cols + k] = sqrt(pooling_value);
        }
    }
    pool.set_shallow_data(data, rows, cols);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x48(%rsp), %rax
imulq 0x40(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x2df41
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x2df2c
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x2deec
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x2ded7
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
imulq 0x38(%rsp), %rsi
addq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
imulq 0x38(%rsp), %rdx
addq 0x8(%rsp), %rdx
callq 0x2a0c0
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2dea2
jp 0x2dea2
jmp 0x2dec2
movss 0x4(%rsp), %xmm0
movss 0x4(%rsp), %xmm2
movss 0x1c(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
jmp 0x2dec4
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2de50
jmp 0x2ded9
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2de37
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x92a0
cvtsd2ss %xmm0, %xmm0
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
imulq 0x40(%rsp), %rcx
addq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2de15
jmp 0x2df2e
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2ddfc
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x30ce0
addq $0x68, %rsp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2260
movq -0x48(%rbp), %rdi
callq 0x5780
cmpq $0x1, %rax
jbe 0x3b00
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x5760
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2040
jmp 0x3ae4
jmp 0x3b14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2100
jmp 0x3bae
leaq 0x35bb(%rip), %rsi      # 0x70c2
leaq -0x28(%rbp), %rdi
callq 0x2240
jmp 0x3b12
jmp 0x3b14
movq -0x48(%rbp), %rdi
callq 0x5780
cmpq $0x3, %rax
jbe 0x3b82
movq 0x649e(%rip), %rdi      # 0x9fc8
leaq 0x3534(%rip), %rsi      # 0x7065
callq 0x21b0
movq %rax, -0x50(%rbp)
jmp 0x3b3c
movq -0x50(%rbp), %rdi
leaq 0x3526(%rip), %rsi      # 0x706d
callq 0x21b0
jmp 0x3b4e
movq 0x6473(%rip), %rdi      # 0x9fc8
leaq 0x3519(%rip), %rsi      # 0x7075
callq 0x21b0
movq %rax, -0x58(%rbp)
jmp 0x3b67
movq -0x58(%rbp), %rdi
leaq 0x3528(%rip), %rsi      # 0x709a
callq 0x21b0
jmp 0x3b79
movl $0x1, -0x38(%rbp)
jmp 0x3b9f
leaq -0x28(%rbp), %rdi
callq 0x20b0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2280
movl $0x0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2100
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x64, %esi
callq 0x20d0
leaq -0x70(%rbp), %rsi
leaq 0x2d8e(%rip), %rdi      # 0x704d
movl $0x1, %edx
callq 0x22b0
leaq -0x90(%rbp), %rdi
callq 0x2260
movq -0xb0(%rbp), %rdi
callq 0x5780
cmpq $0x1, %rax
jne 0x437f
movq 0x5cd6(%rip), %rdi      # 0x9fc8
leaq 0x2d6c(%rip), %rsi      # 0x7065
callq 0x21b0
movq %rax, -0xb8(%rbp)
jmp 0x4307
movq -0xb8(%rbp), %rdi
leaq 0x2d58(%rip), %rsi      # 0x706d
callq 0x21b0
jmp 0x431c
movq 0x5ca5(%rip), %rdi      # 0x9fc8
leaq 0x2d4b(%rip), %rsi      # 0x7075
callq 0x21b0
movq %rax, -0xc0(%rbp)
jmp 0x4338
movq -0xc0(%rbp), %rdi
leaq 0x2da2(%rip), %rsi      # 0x70e8
callq 0x21b0
jmp 0x434d
movl $0x1, -0xa0(%rbp)
jmp 0x44b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2100
jmp 0x44cd
movq -0xb0(%rbp), %rdi
callq 0x5780
cmpq $0x2, %rax
jne 0x43b5
movq -0xb0(%rbp), %rdi
movl $0x1, %esi
callq 0x5760
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x2040
jmp 0x43b3
jmp 0x4426
movq 0x5c0c(%rip), %rdi      # 0x9fc8
leaq 0x2ca2(%rip), %rsi      # 0x7065
callq 0x21b0
movq %rax, -0xc8(%rbp)
jmp 0x43d1
movq -0xc8(%rbp), %rdi
leaq 0x2c8e(%rip), %rsi      # 0x706d
callq 0x21b0
jmp 0x43e6
movq 0x5bdb(%rip), %rdi      # 0x9fc8
leaq 0x2c81(%rip), %rsi      # 0x7075
callq 0x21b0
movq %rax, -0xd0(%rbp)
jmp 0x4402
movq -0xd0(%rbp), %rdi
leaq 0x2d01(%rip), %rsi      # 0x7111
callq 0x21b0
jmp 0x4417
movl $0x1, -0xa0(%rbp)
jmp 0x44b8
leaq -0x90(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
callq 0x2210
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x449a
movq 0x5b76(%rip), %rdi      # 0x9fc8
leaq 0x2cd6(%rip), %rsi      # 0x712f
callq 0x21b0
movq %rax, -0xd8(%rbp)
jmp 0x4467
movq -0xd8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2180
movq %rax, -0xe0(%rbp)
jmp 0x4483
movq -0xe0(%rbp), %rdi
leaq 0x2cb7(%rip), %rsi      # 0x7148
callq 0x21b0
jmp 0x4498
jmp 0x44ae
leaq -0x90(%rbp), %rdi
callq 0x20b0
movq %rax, %rdi
callq 0x2250
movl $0x0, -0xa0(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2100
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x2320
nopl (%rax)
// File: sanaa-khan[P]mini-linux-shell/gbsh.cpp
// Function: pipeCommands(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 pipeCommands(vector<string> tokens) {

	string cmd1, cmd2;

	for (int i = 0; i < tokens.size(); i++) {
		if (tokens[i].size() == 1 and tokens[i][0] == '|') {
			if (i == 0 or i == tokens.size() - 1) {
				cout << "\033[1;31m" << "Error: ";
				cout << "\033[0;38m" << "Command missing.\n";
				return;
			}

			else {
				cmd1 = tokens[0];
				cmd2 = tokens[i + 1];
				break;
			}
		}
	}

	return; // error here fix later

	int fd[2];
	pipe(fd);

	if (!fork()) {
		close(1);
		dup(fd[1]);
		close(fd[0]);
		
		if (!fork()) {
			execl(cmd1.c_str(), cmd1.c_str(), NULL);
		}

		else {
			wait(NULL);
		}
	}

	else {
		close(0);
		dup(fd[0]);
		close(fd[1]);
		execl(cmd2.c_str(), cmd2.c_str(), NULL);
	} 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2260
leaq -0x48(%rbp), %rdi
callq 0x2260
movl $0x0, -0x4c(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x4c(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x5780
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x4683
movq -0x70(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x5760
movq %rax, %rdi
callq 0x2120
cmpq $0x1, %rax
jne 0x4673
movq -0x70(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x5760
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2340
movq %rax, -0x80(%rbp)
jmp 0x456b
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x4673
cmpl $0x0, -0x4c(%rbp)
je 0x45ac
movq -0x70(%rbp), %rdi
movslq -0x4c(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x5780
movq %rax, %rcx
movq -0x88(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4637
movq 0x5a15(%rip), %rdi      # 0x9fc8
leaq 0x2aab(%rip), %rsi      # 0x7065
callq 0x21b0
movq %rax, -0x90(%rbp)
jmp 0x45c8
movq -0x90(%rbp), %rdi
leaq 0x2a97(%rip), %rsi      # 0x706d
callq 0x21b0
jmp 0x45dd
movq 0x59e4(%rip), %rdi      # 0x9fc8
leaq 0x2a8a(%rip), %rsi      # 0x7075
callq 0x21b0
movq %rax, -0x98(%rbp)
jmp 0x45f9
movq -0x98(%rbp), %rdi
leaq 0x2b52(%rip), %rsi      # 0x7159
callq 0x21b0
jmp 0x460e
movl $0x1, -0x60(%rbp)
jmp 0x468a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2100
leaq -0x28(%rbp), %rdi
callq 0x2100
jmp 0x46a5
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5760
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2040
jmp 0x4652
movq -0x70(%rbp), %rdi
movl -0x4c(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x5760
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x2040
jmp 0x4671
jmp 0x4683
jmp 0x4675
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x450c
movl $0x1, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2100
leaq -0x28(%rbp), %rdi
callq 0x2100
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2320
nop
// File: gualtieromalde[P]owmread/owmread.C
// Function: setMetar(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void setMetar(int port, std::string metar)
{
    CURL* curl = curl_easy_init();
    const std::string url = "http://localhost:" + std::to_string(port) + "/props/environment/metar?submit=set&data[0]=" + curl_easy_escape(curl, metar.c_str(), metar.size());
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, no_write_data);
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
    curl_easy_perform(curl);
    curl_easy_cleanup(curl);
}

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0x20(%rsp)
movl %edi, 0xd4(%rsp)
movq %rsi, 0xc8(%rsp)
callq 0xaa10
movq %rax, 0xc0(%rsp)
movl 0xd4(%rsp), %esi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xef70
movq 0x28(%rsp), %rdx
leaq 0x38d81(%rip), %rsi     # 0x4667b
leaq 0x60(%rsp), %rdi
callq 0xf160
jmp 0xd906
leaq 0x38dbf(%rip), %rdx     # 0x466cc
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xf0b0
jmp 0xd921
movq 0x20(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xa180
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0xa310
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0xa710
movq %rax, 0x18(%rsp)
jmp 0xd95f
movq 0x18(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xf0b0
jmp 0xd97b
leaq 0x80(%rsp), %rdi
callq 0xac68
leaq 0x60(%rsp), %rdi
callq 0xac68
leaq 0x40(%rsp), %rdi
callq 0xac68
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
leaq 0xa0(%rsp), %rdi
callq 0xa180
movq (%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl $0x2712, %esi           # imm = 0x2712
callq 0xa8b0
jmp 0xd9ca
movq 0xc0(%rsp), %rdi
xorl %eax, %eax
movl $0x71, %esi
movl $0x1, %edx
callq 0xa8b0
jmp 0xd9e5
movq 0xc0(%rsp), %rdi
xorl %eax, %eax
movl $0xd, %esi
movl $0xa, %edx
callq 0xa8b0
jmp 0xda00
movq 0xc0(%rsp), %rdi
leaq 0xe1(%rip), %rdx        # 0xdaf0
xorl %eax, %eax
movl $0x4e2b, %esi           # imm = 0x4E2B
callq 0xa8b0
jmp 0xda1d
movq 0xc0(%rsp), %rdi
xorl %eax, %eax
movl $0x34, %esi
movl $0x1, %edx
callq 0xa8b0
jmp 0xda38
movq 0xc0(%rsp), %rdi
callq 0xa6d0
jmp 0xda47
movq 0xc0(%rsp), %rdi
callq 0xa1c0
jmp 0xda56
leaq 0xa0(%rsp), %rdi
callq 0xac68
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xdab0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xdaa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xac68
leaq 0x60(%rsp), %rdi
callq 0xac68
leaq 0x40(%rsp), %rdi
callq 0xac68
jmp 0xdad7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0xac68
movq 0x38(%rsp), %rdi
callq 0xa670
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4190
movl $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3240
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ae5
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x33a0
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x3a53
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x33a0
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x3a53
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x33a0
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3ac1
testb $0x1, -0x19(%rbp)
jne 0x3a5b
jmp 0x3ad4
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x48(%rbp), %rdi
callq 0x3340
jmp 0x3a79
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x41b0
jmp 0x3a8b
leaq -0x48(%rbp), %rdi
callq 0x35f8
jmp 0x3ad4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x3b80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x35f8
jmp 0x3b80
testb $0x1, -0x19(%rbp)
je 0x3ac9
jmp 0x3ad4
movb $0x1, -0x19(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x39ed
testb $0x1, -0x19(%rbp)
je 0x3b5d
movq -0x10(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x3240
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
movslq -0x18(%rbp), %rax
subq %rax, %rcx
leaq -0x78(%rbp), %rdi
callq 0x3340
jmp 0x3b29
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x41b0
jmp 0x3b3b
leaq -0x78(%rbp), %rdi
callq 0x35f8
jmp 0x3b5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x35f8
jmp 0x3b80
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3b73
movq -0x88(%rbp), %rdi
callq 0x41e0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x41e0
movq -0x50(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x34e0
leaq -0x230(%rbp), %rdi
callq 0x3440
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x30a0
movq %rax, -0x248(%rbp)
jmp 0x3beb
movq -0x248(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3410
movb %al, -0x249(%rbp)
jmp 0x3c09
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x3c15
jmp 0x3c74
movq 0x283ac(%rip), %rdi     # 0x2bfc8
leaq -0x230(%rbp), %rsi
callq 0x32d0
movq %rax, -0x258(%rbp)
jmp 0x3c31
movq -0x258(%rbp), %rdi
movq 0x28361(%rip), %rsi     # 0x2bfa0
callq 0x3360
jmp 0x3c46
jmp 0x3bcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x35f8
leaq -0x210(%rbp), %rdi
callq 0x30c0
jmp 0x3c95
leaq -0x230(%rbp), %rdi
callq 0x35f8
leaq -0x210(%rbp), %rdi
callq 0x30c0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3240
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4180
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
shrl $0x8, %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x2c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x35e0
movl -0x30(%rbp), %ecx
movq %rax, %rdx
movl -0x2c(%rbp), %eax
movsbl (%rdx), %edx
xorl %edx, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x17f64(%rip), %rcx     # 0x1c0d0
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x410f
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: momohatt[P]seccampDB/database.cpp
// Function: Transaction::begin()
void Transaction::begin() {
    TXLOG;
    unique_lock<mutex> lock(giant_mtx_);
    lock_ = move(lock);
    wait();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x74(%rax), %esi
leaq 0x16fb2(%rip), %rdi     # 0x1c4d0
leaq 0x16b35(%rip), %rdx     # 0x1c05a
xorl %eax, %eax
movl $0x20, %ecx
callq 0x3070
leaq 0x26de8(%rip), %rsi     # 0x2c320
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x9270
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x90, %rdi
callq 0x92b0
movq -0x30(%rbp), %rdi
callq 0x55a0
jmp 0x5564
leaq -0x18(%rbp), %rdi
callq 0x9330
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9330
movq -0x20(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x74(%rax), %esi
leaq 0x16ebf(%rip), %rdi     # 0x1c4d0
leaq 0x16a5b(%rip), %rdx     # 0x1c073
movl $0x27, %ecx
movb $0x0, %al
callq 0x3070
movq -0x60(%rbp), %rsi
movq 0xd8(%rsi), %rdi
callq 0x5700
movq -0x60(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d60
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9370
testb $0x1, %al
jne 0x566d
jmp 0x56e5
leaq -0x18(%rbp), %rdi
callq 0x53f0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0xe0(%rax), %rcx
movq %rcx, -0x78(%rbp)
movl 0x74(%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3150
movq -0x78(%rbp), %rdi
movl -0x6c(%rbp), %esi
movq -0x68(%rbp), %rdx
movl $0x1, %ecx
callq 0x93b0
jmp 0x56ba
leaq -0x48(%rbp), %rdi
callq 0x35f8
leaq -0x18(%rbp), %rdi
callq 0x93f0
jmp 0x565a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x35f8
jmp 0x56f7
movq -0x60(%rbp), %rdi
callq 0x5950
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3540
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa380
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7e30
jmp 0x574b
leaq -0x60(%rbp), %rdi
callq 0xa2e0
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3240
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0x582a
movq -0xb8(%rbp), %rax
movl 0x78(%rax), %eax
movl %eax, -0xd4(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3140
movq -0xe0(%rbp), %rdi
movq -0x78(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xd0(%rbp)
callq 0x3240
movl -0xd4(%rbp), %edi
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
movq -0x78(%rbp), %rax
subq %rax, %rdx
callq 0x3100
movq %rax, -0xc8(%rbp)
jmp 0x57e2
movq -0xc8(%rbp), %rax
addq -0x78(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x575c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa2e0
jmp 0x593d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35f8
jmp 0x593d
movq -0xb8(%rbp), %rax
movl 0x78(%rax), %edi
callq 0x32b0
jmp 0x583b
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x98c0
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0x98f0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x9920
testb $0x1, %al
jne 0x587f
jmp 0x592b
leaq -0x88(%rbp), %rdi
callq 0x9950
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x9970
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
callq 0x9990
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x5901
movq -0xb8(%rbp), %rdi
movq -0xa8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xec(%rbp)
movq -0xa0(%rbp), %rsi
callq 0x96d0
movq %rax, -0xe8(%rbp)
jmp 0x58f0
movq -0xe8(%rbp), %rax
movl -0xec(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x5918
movq -0xb8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0xa2b0
jmp 0x5916
jmp 0x5918
jmp 0x591a
leaq -0x88(%rbp), %rdi
callq 0x99b0
jmp 0x5863
leaq -0x30(%rbp), %rdi
callq 0x35f8
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x98c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x98f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9920
testb $0x1, %al
jne 0x599e
jmp 0x5a1e
leaq -0x18(%rbp), %rdi
callq 0x9950
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3150
movq -0x90(%rbp), %rax
movq -0xa0(%rbp), %rsi
movq 0xd8(%rax), %rdi
callq 0x96d0
movq %rax, -0x98(%rbp)
jmp 0x59e2
movq -0x98(%rbp), %rax
movl $0x0, 0x4(%rax)
leaq -0x48(%rbp), %rdi
callq 0x35f8
leaq -0x18(%rbp), %rdi
callq 0x99b0
jmp 0x5988
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x35f8
jmp 0x5aed
movq -0x90(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4f20
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x4d60
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9370
testb $0x1, %al
jne 0x5a5a
jmp 0x5a93
leaq -0x68(%rbp), %rdi
callq 0x53f0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x78(%rbp)
movq 0xd8(%rax), %rdi
movq -0x78(%rbp), %rsi
callq 0x96d0
movl $0x0, 0x4(%rax)
leaq -0x68(%rbp), %rdi
callq 0x93f0
jmp 0x5a47
leaq -0x88(%rbp), %rdi
callq 0x9a70
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x9a90
movq -0x90(%rbp), %rdi
movb $0x1, 0x48(%rdi)
movb $0x0, 0x70(%rdi)
addq $0x90, %rdi
callq 0x9ae0
movq -0x90(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0x9a40
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x74(%rax), %esi
leaq 0x16964(%rip), %rdi     # 0x1c4d0
leaq 0x16491(%rip), %rdx     # 0x1c004
movl $0x35, %ecx
movb $0x0, %al
callq 0x3070
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0x9410
cmpq $0x0, %rax
jbe 0x5c14
jmp 0x5b9b
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rsi
movq 0xd8(%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3150
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x70(%rbp), %rdx
movl $0x1, %ecx
callq 0x5c80
movb %al, -0x61(%rbp)
jmp 0x5bd6
movb -0x61(%rbp), %al
xorb $-0x1, %al
movb %al, -0x79(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35f8
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x5bf0
jmp 0x5c12
movq -0x58(%rbp), %rdi
callq 0x55a0
jmp 0x5b9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35f8
jmp 0x5c6c
jmp 0x5c14
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x78, %rdi
callq 0x9470
movl $0x0, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x94e0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq %rax, -0x4c(%rbp)
callq 0x9510
movq %rax, %rdi
leaq -0x4c(%rbp), %rsi
callq 0x95f0
movq -0x58(%rbp), %rdi
callq 0x55a0
xorl %eax, %eax
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x74(%rax), %esi
leaq 0x16241(%rip), %rdi     # 0x1c4d0
leaq 0x15dc0(%rip), %rdx     # 0x1c056
xorl %eax, %eax
movl $0x60, %ecx
callq 0x3070
movq -0x98(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3150
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x61f0
movb %al, -0x79(%rbp)
jmp 0x62d1
movb -0x79(%rbp), %al
xorb $-0x1, %al
movb %al, -0x99(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35f8
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x62f1
jmp 0x6314
movb $0x1, -0x1(%rbp)
jmp 0x6419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35f8
jmp 0x6427
jmp 0x6316
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rsi
movq 0xd8(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3150
movq -0xb0(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movl $0x1, %ecx
callq 0x5c80
movb %al, -0x9a(%rbp)
jmp 0x6369
movb -0x9a(%rbp), %al
xorb $-0x1, %al
movb %al, -0xb1(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35f8
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x638c
jmp 0x63b4
movq -0x90(%rbp), %rdi
callq 0x55a0
jmp 0x6316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35f8
jmp 0x6427
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
addq $0x78, %rdi
callq 0x9470
movl $0x1, -0x74(%rbp)
movl $0x0, -0x78(%rbp)
leaq -0x74(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x97b0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x9510
movq %rax, %rdi
leaq -0x70(%rbp), %rsi
callq 0x95f0
movq -0x90(%rbp), %rdi
callq 0x55a0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3540
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl 0x74(%rax), %esi
leaq 0x15dd1(%rip), %rdi     # 0x1c4d0
leaq 0x15e00(%rip), %rdx     # 0x1c506
xorl %eax, %eax
movl $0x83, %ecx
callq 0x3070
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3150
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x5e90
movq %rax, -0x78(%rbp)
jmp 0x673c
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35f8
leaq -0x18(%rbp), %rdi
callq 0x99e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x6761
jmp 0x67ec
movq -0x88(%rbp), %rdi
callq 0x55a0
movq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3150
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x5e90
movq %rax, -0x98(%rbp)
jmp 0x67a0
movq -0x98(%rbp), %rax
movq %rax, -0x4c(%rbp)
movq -0x4c(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35f8
jmp 0x674d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35f8
jmp 0x680c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35f8
jmp 0x680c
movq -0x88(%rbp), %rdi
callq 0x55a0
leaq -0x18(%rbp), %rdi
callq 0x9a00
movl (%rax), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x158a5(%rip), %rdi     # 0x1c518
leaq 0x158b5(%rip), %rsi     # 0x1c52f
xorl %eax, %eax
movl $0xb1, %edx
callq 0x3070
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x91a0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x6d20
jmp 0x6cb9
leaq -0x38(%rbp), %rdi
callq 0x9ce0
movq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9d00
jmp 0x6cd1
leaq -0x18(%rbp), %rdi
callq 0x9d30
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9ce0
jmp 0x6d0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9d30
movq -0x40(%rbp), %rdi
callq 0x3540
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0x254cf(%rip), %rsi     # 0x2c320
leaq -0x18(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x9270
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
addq $0x88, %rdi
callq 0x92b0
leaq 0x15696(%rip), %rdi     # 0x1c518
leaq 0x156ad(%rip), %rsi     # 0x1c536
xorl %eax, %eax
movl $0xbb, %edx
callq 0x3070
jmp 0x6e97
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x9d90
jmp 0x6eb1
movq -0x30(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x9dc0
jmp 0x6ec0
jmp 0x6ec2
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9df0
testb $0x1, %al
jne 0x6ed8
jmp 0x6f75
leaq -0x50(%rbp), %rdi
callq 0x9e20
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x9e40
addq $0x50, %rax
movq %rax, -0xa0(%rbp)
movq -0x78(%rbp), %rdi
callq 0x9e60
movq -0xa0(%rbp), %rsi
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x9e90
jmp 0x6f22
movq -0x78(%rbp), %rdi
callq 0x9e40
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x9f50
jmp 0x6f39
leaq -0x80(%rbp), %rdi
callq 0x9f80
leaq -0x50(%rbp), %rdi
callq 0x9fb0
jmp 0x6ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6f95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9f80
jmp 0x6f95
movq -0x98(%rbp), %rdi
callq 0x6fb0
jmp 0x6f83
leaq -0x18(%rbp), %rdi
callq 0x9330
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x9330
movq -0x20(%rbp), %rdi
callq 0x3540
nopw (%rax,%rax)
// File: momohatt[P]seccampDB/database.cpp
// Function: Scheduler::run()
void Scheduler::run() {
    while (!transactions.empty()) {
        unique_ptr<Transaction> tx = move(transactions.front());
        transactions.pop();
        wait(tx.get());

        if (tx->is_done) {
            tx->terminate();
            tx.reset();
            continue;
        }
        transactions.push(move(tx));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa000
xorb $-0x1, %al
testb $0x1, %al
jne 0x6fd8
jmp 0x7090
movq -0x28(%rbp), %rdi
callq 0xa020
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0xa040
movq -0x28(%rbp), %rdi
callq 0xa070
jmp 0x6ff8
leaq -0x10(%rbp), %rdi
callq 0x9e60
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x70a0
jmp 0x700f
leaq -0x10(%rbp), %rdi
callq 0x9e40
testb $0x1, 0x48(%rax)
je 0x705e
leaq -0x10(%rbp), %rdi
callq 0x9e40
movq %rax, %rdi
callq 0xa090
jmp 0x7031
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa0c0
movl $0x2, -0x20(%rbp)
jmp 0x7074
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9d30
jmp 0x7096
movq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9d00
jmp 0x706d
movl $0x0, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9d30
movl -0x20(%rbp), %eax
testl %eax, %eax
je 0x708b
jmp 0x7086
jmp 0x6fc4
jmp 0x6fc4
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3540
nop