LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/pawan231[P]MiniDataBase/include/BPtree.h
// Function: BPtree::update_meta_data()
void update_meta_data()
    {
        char *str;
        str = (char *) malloc(sizeof(char) * BPTREE_MAX_FILE_PATH_SIZE);
        sprintf(str, "table/%s/tree/meta_tree.dat", tablename);
        std::ofstream out_file(str, std::ofstream::out | std::ofstream::trunc
                                        | std::ofstream::binary );
        out_file << files_till_now << " " << root_num;
        out_file.close();
        free(str);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %r14
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2250
movq %rax, %rbx
leaq 0x8(%r14), %rdx
leaq 0x1a8b(%rip), %rsi      # 0x68d0
movq %rax, %rdi
xorl %eax, %eax
callq 0x2040
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x34, %edx
callq 0x21c0
movl (%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %rax, %r15
leaq 0x1c6c(%rip), %rsi      # 0x6ae3
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x2330
movq %rsp, %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2210
movq 0x4119(%rip), %rax      # 0x8fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2130
leaq 0xf8(%rsp), %rdi
callq 0x2080
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::operator=(Btreenode const&)
Btreenode & operator=(const Btreenode & n)
    {
        if (this != &n)
        {
            leaf = n.leaf;
            keys.assign(n.keys.begin(), n.keys.end());
            pointers.assign(n.pointers.begin(), n.pointers.end());
        }
        return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x4f27
movq %rsi, %r14
movb (%rsi), %al
movb %al, (%rbx)
leaq 0x20(%rbx), %rdi
movq 0x20(%rsi), %rsi
movq 0x28(%r14), %rdx
callq 0x592e
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
callq 0x592e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::copy_first(Btreenode&, int)
void copy_first(Btreenode & node, int n)
    {
        keys.clear();
        pointers.clear();
        for (int i = 1; i < n; i++)
        {
            keys.push_back(node.get_key(i));
            pointers.push_back(node.get_pointer(i));
        }
        pointers.push_back(node.get_pointer(n));
        if (leaf)
        {
            keys.push_back(node.get_key(n));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq %rax, 0x28(%rdi)
je 0x4f54
movq %rax, 0x28(%rbx)
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x4f62
movq %rax, 0x10(%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rbx), %r12
movl %edx, 0xc(%rsp)
cmpl $0x2, %edx
jl 0x4feb
movl 0xc(%rsp), %ebp
decq %rbp
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
movq 0x20(%r14), %rax
movl (%rax,%r15,4), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x4fa9
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%rbx)
jmp 0x4fb6
movq 0x10(%rsp), %rdi
movq %r13, %rdx
callq 0x5a26
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x4fd8
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x4fe3
movq %r12, %rdi
movq %r13, %rdx
callq 0x5a26
incq %r15
cmpq %r15, %rbp
jne 0x4f87
movq 0x8(%r14), %rax
movslq 0xc(%rsp), %r15
movl -0x4(%rax,%r15,4), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x5013
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x5020
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x5a26
cmpb $0x0, (%rbx)
je 0x5057
movq 0x20(%r14), %rax
movl -0x4(%rax,%r15,4), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x5048
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%rbx)
jmp 0x5057
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rdi
callq 0x5a26
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pawan231[P]MiniDataBase/include/BPtree.h
// Function: Btreenode::copy_last(Btreenode&, int)
void copy_last(Btreenode & node, int n)
    {
        keys.clear();
        pointers.clear();
        int lim = node.num_pointers();
        for (int i = n + 1; i <= lim; i++)
        {
            pointers.push_back(node.get_pointer(i));
        }
        lim = node.num_keys();
        for (int i = n + 1; i <= lim; i++)
        {
            keys.push_back(node.get_key(i));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
cmpq %rax, 0x28(%rdi)
je 0x5088
movq %rax, 0x28(%r14)
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x5096
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %r13
subq 0x8(%rbx), %r13
shrq $0x2, %r13
movl %edx, 0xc(%rsp)
subl %edx, %r13d
jle 0x50ed
leaq 0x8(%r14), %r15
movslq 0xc(%rsp), %rbp
leaq 0x14(%rsp), %r12
movq 0x8(%rbx), %rax
movl (%rax,%rbp,4), %eax
movl %eax, 0x14(%rsp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x50da
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%r14)
jmp 0x50e5
movq %r15, %rdi
movq %r12, %rdx
callq 0x5a26
incq %rbp
decl %r13d
jne 0x50b9
movq 0x28(%rbx), %r13
subq 0x20(%rbx), %r13
shrq $0x2, %r13
movl 0xc(%rsp), %eax
subl %eax, %r13d
jle 0x5142
leaq 0x20(%r14), %r15
movslq %eax, %rbp
leaq 0x10(%rsp), %r12
movq 0x20(%rbx), %rax
movl (%rax,%rbp,4), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%r14), %rsi
cmpq 0x30(%r14), %rsi
je 0x512f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%r14)
jmp 0x513a
movq %r15, %rdi
movq %r12, %rdx
callq 0x5a26
incq %rbp
decl %r13d
jne 0x510e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pawan231[P]MiniDataBase/include/BPtree.h
// Function: operator>>(std::basic_ifstream<char, std::char_traits<char>>&, Btreenode&)
std::ifstream & operator>>(std::ifstream & is, Btreenode & en)
    {
        int ts;
        is >> en.leaf;
        is >> ts;
        en.keys.resize(ts);
        for (int i = 0; i < ts; i++)
        {
            is >> en.keys[i];
        }
        is >> ts;
        en.pointers.resize(ts);
        for (int i = 0; i < ts; i++)
        {
            is >> en.pointers[i];
        }
        is >> en.next_node;
        return is;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2150
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2100
leaq 0x20(%r14), %r15
movslq (%r12), %rsi
movq %r15, %rdi
callq 0x5496
cmpl $0x0, (%r12)
jle 0x541e
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x2100
incq %r13
movslq 0xc(%rsp), %rax
addq $0x4, %r12
cmpq %rax, %r13
jl 0x53ff
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2100
leaq 0x8(%r14), %r15
movslq (%r12), %rsi
movq %r15, %rdi
callq 0x5496
cmpl $0x0, (%r12)
jle 0x546a
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x2100
incq %r13
movslq 0xc(%rsp), %rax
addq $0x4, %r12
cmpq %rax, %r13
jl 0x544b
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2100
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/pawan231[P]MiniDataBase/include/BPtree.h
// Function: operator<<(std::basic_ofstream<char, std::char_traits<char>>&, Btreenode const&)
std::ofstream & operator<<(std::ofstream & os, const Btreenode & en)
    {
        os << en.leaf << " ";
        os << (int) en.keys.size() << " ";
        for (unsigned int i = 0; i < en.keys.size(); i++)
        {
            os << en.keys[i] << " ";
        }
        os << (int) en.pointers.size() << " ";
        for (unsigned int i = 0; i < en.pointers.size(); i++)
        {
            os << en.pointers[i] << " ";
        }
        os << en.next_node;
        return os;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %esi
callq 0x2300
leaq 0x1342(%rip), %r15      # 0x6ae3
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
movq 0x28(%r14), %rsi
subq 0x20(%r14), %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
movq 0x20(%r14), %rax
cmpq %rax, 0x28(%r14)
je 0x5820
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x12f6(%rip), %r15      # 0x6ae3
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
movl %ebp, %ecx
movq 0x20(%r14), %rax
movq 0x28(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x57ed
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x2330
leaq 0x12a8(%rip), %rsi      # 0x6ae3
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x5893
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x1283(%rip), %r15      # 0x6ae3
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
movl %ebp, %ecx
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5860
movl 0x38(%r14), %esi
movq %rbx, %rdi
callq 0x2330
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/BIsHetAntwoord[P]TemplateBF/main.cpp
// Function: main
int main()
{
    using tape = MakeArray<Byte<0>, 256>::value;
    using code = MakeCharArray<',', '[', '.', '+', ']', '\0'>::value;
    using input = MakeByteArray<'A'>::value;
    using output = void;

    using machine = Machine<tape, code, input, output, 0, 0, true>;

    using result = machine::output;
    #ifdef PRINT_BYTES
    print_byte_array<result>(std::cout);
    #else
    print_char_array<result>(std::cout);
    #endif
    std::cout << std::endl;

    #ifdef PRINT_TAPE
    using result_tape = machine::tape;
    print_byte_array<result_tape>(std::cout);
    std::cout << std::endl;
    #endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xf(%rsp), %rsi
movb $0x41, (%rsi)
movq 0x4e06(%rip), %rbx      # 0x5fd8
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1216
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/tests/basic_arith.cpp
// Function: main
int main()
{
	bool success = true;
	
	success &= add_test();
	success &= sub_test();
	success &= mul_test();
	success &= div_test();
	success &= pow_test();
	success &= mod_test();
	
	return success ? EXIT_SUCCESS : EXIT_FAILURE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x64c6
movl %eax, %ebx
callq 0x6796
movl %eax, %ebp
andb %bl, %bpl
callq 0x6a66
movl %eax, %ebx
callq 0x6d36
movl %eax, %r14d
andb %bl, %r14b
andb %bpl, %r14b
callq 0x7006
movl %eax, %ebx
callq 0x72d6
andb %bl, %al
andb %r14b, %al
xorb $0x1, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator+=(crolol::num)
num& num::operator+=(num rhs)
{
	// If the sign of lhs and rhs aren't the same, we can always add.
	// Same if either args are 0.
	if ((bi < 0) != (rhs.bi < 0) || bi == 0 || rhs.bi == 0)
		bi += rhs.bi;
	else if (bi < 0) {
		if (num_min - bi > rhs.bi)
			bi = num_min;
		else bi += rhs.bi;
	} else {
		if (num_max - bi < rhs.bi)
			bi = num_max;
		else bi += rhs.bi;
	}
	
	return *this;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
movq %rcx, %rdx
xorq %rsi, %rdx
js 0x785a
testq %rcx, %rcx
setne %dl
testq %rsi, %rsi
setne %dil
testb %dl, %dil
jne 0x785f
addq %rsi, %rcx
jmp 0x7894
leaq (%rcx,%rsi), %rdx
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
testq %rcx, %rcx
js 0x7881
movq %rdi, %r8
subq %rcx, %r8
cmpq %rsi, %r8
cmovlq %rdi, %rdx
jmp 0x7891
incq %rdi
movq %rdi, %r8
subq %rcx, %r8
cmpq %rsi, %r8
cmovgq %rdi, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator-=(crolol::num)
num& num::operator-=(num rhs)
{
	// If sgn(lhs) == sgn(rhs) or rhs or lhs == 0, we can subtract.
	// EXCEPT if rhs == num_min, as that would allow 0-(-2^63)=2^63.
	if (((bi < 0) == (rhs.bi < 0)) ||
		((rhs.bi == 0 || bi == 0) && rhs.bi != num_min))
		bi -= rhs.bi;
	else if (rhs.bi == num_min) *this += num::max();
	else *this += -rhs.bi;
	
	return *this;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movq %rcx, %rax
xorq %rsi, %rax
setns %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x78c7
testq %rcx, %rcx
setne %dl
movq %rsi, %rax
negq %rax
seto %dil
orb %dl, %dil
jne 0x78cf
subq %rsi, %rcx
movq %rcx, (%rbx)
jmp 0x78f4
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, %rsi
jne 0x78e9
decq %rcx
movq %rbx, %rdi
movq %rcx, %rsi
jmp 0x78ef
movq %rbx, %rdi
movq %rax, %rsi
callq 0x783a
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator*=(crolol::num)
num& num::operator*=(num rhs)
{
	const backend::saferet result = backend::multiply(bi, rhs.bi);
	
	switch (result.flow) {
		case backend::badarg: throw std::invalid_argument("Bad mult");
		case backend::underflow: *this = num::min(); return *this;
		case backend::overflow: *this = num::max(); return *this;
		default: *this = result.val; return *this;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
movq (%rdi), %rdi
callq 0x7dfc
cmpl $0x1, %edx
je 0x7927
cmpl $0x2, %edx
je 0x792a
cmpl $0x3, %edx
je 0x7938
movq %rax, %r14
jmp 0x792a
incq %r14
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4180
movq %rax, %rbx
leaq 0x12818(%rip), %rsi     # 0x1a164
movq %rax, %rdi
callq 0x4540
movq 0x1f685(%rip), %rsi     # 0x26fe0
movq 0x1f66e(%rip), %rdx     # 0x26fd0
movq %rbx, %rdi
callq 0x44d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator/=(crolol::num)
num& num::operator/=(num rhs)
{
	const backend::saferet result = backend::divide(bi, rhs.bi);
	
	switch (result.flow) {
		case backend::badarg: throw std::invalid_argument("Bad div");
		case backend::underflow: *this = num::min(); return *this;
		case backend::overflow: *this = num::max(); return *this;
		default: *this = result.val; return *this;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
movq (%rdi), %rdi
callq 0x7fcb
cmpl $0x1, %edx
je 0x79ab
cmpl $0x2, %edx
je 0x79ae
cmpl $0x3, %edx
je 0x79bc
movq %rax, %r14
jmp 0x79ae
incq %r14
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4180
movq %rax, %rbx
leaq 0x1279d(%rip), %rsi     # 0x1a16d
movq %rax, %rdi
callq 0x4540
movq 0x1f601(%rip), %rsi     # 0x26fe0
movq 0x1f5ea(%rip), %rdx     # 0x26fd0
movq %rbx, %rdi
callq 0x44d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/num.cpp
// Function: crolol::num::operator%=(crolol::num)
num& num::operator%=(num rhs)
{
	const bool sign = rhs.bi < 0;
	
	bi = abs(*this).bi % abs(rhs).bi;
	
	if (sign) *this = -*this;
	
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
jns 0x7a32
movq %rsp, %r12
movq $0x0, (%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7898
movq (%r12), %r15
movq %r14, %rcx
testq %r14, %r14
jns 0x7a54
movq %rsp, %r12
movq $0x0, (%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x7898
movq (%r12), %rcx
movq %r15, %rax
cqto
idivq %rcx
movq %rdx, (%rbx)
testq %r14, %r14
jns 0x7a7f
movq %rsp, %r14
movq $0x0, (%r14)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x7898
movq (%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/num.cpp
// Function: operator^(crolol::num, crolol::num)
num operator^(num lhs, num rhs)
{
	const backend::saferet result = backend::pow(lhs.bi, rhs.bi);
	int64_t newv;
	
	switch (result.flow) {
		case backend::badarg: throw std::invalid_argument("Bad pow");
		case backend::underflow: newv = num_min; return newv;
		case backend::overflow: newv = num_max; return newv;
		default: newv = result.val; return newv;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
callq 0x810c
cmpl $0x1, %edx
je 0x7b9e
cmpl $0x2, %edx
je 0x7ba1
cmpl $0x3, %edx
je 0x7bac
movq %rax, %rbx
jmp 0x7ba1
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4180
movq %rax, %rbx
leaq 0x125b5(%rip), %rsi     # 0x1a175
movq %rax, %rdi
callq 0x4540
movq 0x1f411(%rip), %rsi     # 0x26fe0
movq 0x1f3fa(%rip), %rdx     # 0x26fd0
movq %rbx, %rdi
callq 0x44d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/losslessops.cpp
// Function: crolol::backend::factorial(long)
saferet backend::factorial(int64_t n)
{
	if (n < 0 or n % scale != 0) return make_badarg(n);
	
	saferet acc = clamp(scale);
	
	for (int64_t i = 0; i < n && acc.flow == noflow; i += scale)
		acc = multiply(acc.val, i);
	
	return acc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
movq %rdx, %rax
movl $0x3, %edx
testq %rdi, %rdi
js 0x84b1
shrq $0x4, %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rbx, %rcx
subq %rax, %rcx
jne 0x84b1
testq %rbx, %rbx
jle 0x84b6
movl $0x3e8, %r14d           # imm = 0x3E8
movl $0x3e8, %eax            # imm = 0x3E8
leaq -0x3e8(%r14), %rsi
movq %rax, %rdi
callq 0x7dfc
cmpq %rbx, %r14
jge 0x84bd
addq $0x3e8, %r14            # imm = 0x3E8
testl %edx, %edx
je 0x8490
jmp 0x84bd
movq %rbx, %rax
jmp 0x84bd
xorl %edx, %edx
movl $0x3e8, %eax            # imm = 0x3E8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/losslessops.cpp
// Function: crolol::backend::asin(long)
saferet backend::asin(int64_t n)
{
	if (n > scale or n < -scale) return make_badarg(n);
	else return clamp(static_cast<int128>(
		std::truncl(std::asin(
			static_cast<long double>(n) / scale
		)) * scale * radtodeg
	));
}

// Assembly:
movq %rdi, %rax
leaq -0x3e9(%rdi), %rcx
movl $0x3, %edx
cmpq $-0x7d1, %rcx           # imm = 0xF82F
jb 0x87eb
subq $0x28, %rsp
movq %rax, 0x20(%rsp)
fildll 0x20(%rsp)
flds 0x11a1d(%rip)           # 0x1a160
fld %st(0)
fstpt 0x14(%rsp)
fdivrp %st, %st(1)
fstpt (%rsp)
callq 0x4490
fstpt (%rsp)
callq 0x4050
fldt 0x14(%rsp)
fmulp %st, %st(1)
fldt 0x11a69(%rip)           # 0x1a1d0
fmulp %st, %st(1)
fld %st(0)
fstpt 0x14(%rsp)
fabs
fstpt (%rsp)
callq 0x41c0
fldt 0x14(%rsp)
movq %rax, %rcx
movq %rax, %rsi
shrq $0x3f, %rsi
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rdi), %r8
negq %rax
fldz
fucomi %st(1), %st
cmovbeq %rdi, %r8
cmovbeq %rcx, %rax
orq %rdx, %rsi
setne %sil
cmovneq %r8, %rax
fucomi %st(1), %st
leaq 0x28(%rsp), %rsp
jbe 0x87bc
setbe %sil
fucompi %st(1), %st
fstp %st(0)
seta %dil
xorl %r8d, %r8d
movabsq $-0x8000000000000000, %r9 # imm = 0x8000000000000000
cmpq %rcx, %r9
sbbq %rdx, %r8
setb %cl
andb %dil, %cl
movzbl %cl, %ecx
testb %sil, %sil
movl $0x2, %edx
cmovel %ecx, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/losslessops.cpp
// Function: crolol::backend::acos(long)
saferet backend::acos(int64_t n)
{
	if (n > scale or n < -scale) return make_badarg(n);
	else return clamp(static_cast<int128>(
		std::truncl(std::acos(
			static_cast<long double>(n) / scale
		)) * scale * radtodeg
	));
}

// Assembly:
movq %rdi, %rax
leaq -0x3e9(%rdi), %rcx
movl $0x3, %edx
cmpq $-0x7d1, %rcx           # imm = 0xF82F
jb 0x88c3
subq $0x28, %rsp
movq %rax, 0x20(%rsp)
fildll 0x20(%rsp)
flds 0x11945(%rip)           # 0x1a160
fld %st(0)
fstpt 0x14(%rsp)
fdivrp %st, %st(1)
fstpt (%rsp)
callq 0x41f0
fstpt (%rsp)
callq 0x4050
fldt 0x14(%rsp)
fmulp %st, %st(1)
fldt 0x11991(%rip)           # 0x1a1d0
fmulp %st, %st(1)
fld %st(0)
fstpt 0x14(%rsp)
fabs
fstpt (%rsp)
callq 0x41c0
fldt 0x14(%rsp)
movq %rax, %rcx
movq %rax, %rsi
shrq $0x3f, %rsi
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rdi), %r8
negq %rax
fldz
fucomi %st(1), %st
cmovbeq %rdi, %r8
cmovbeq %rcx, %rax
orq %rdx, %rsi
setne %sil
cmovneq %r8, %rax
fucomi %st(1), %st
leaq 0x28(%rsp), %rsp
jbe 0x8894
setbe %sil
fucompi %st(1), %st
fstp %st(0)
seta %dil
xorl %r8d, %r8d
movabsq $-0x8000000000000000, %r9 # imm = 0x8000000000000000
cmpq %rcx, %r9
sbbq %rdx, %r8
setb %cl
andb %dil, %cl
movzbl %cl, %ecx
testb %sil, %sil
movl $0x2, %edx
cmovel %ecx, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ocornoc[P]crolol/src/losslessops.cpp
// Function: crolol::backend::atan(long)
saferet backend::atan(int64_t n)
{
	return clamp(static_cast<int128>(
		std::truncl(std::atan(
			static_cast<long double>(n) / scale
		)) * scale * radtodeg
	));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
fildll 0x20(%rsp)
flds 0x11889(%rip)           # 0x1a160
fld %st(0)
fstpt 0x14(%rsp)
fdivrp %st, %st(1)
fstpt (%rsp)
callq 0x44b0
fstpt (%rsp)
callq 0x4050
fldt 0x14(%rsp)
fmulp %st, %st(1)
fldt 0x118d5(%rip)           # 0x1a1d0
fmulp %st, %st(1)
fld %st(0)
fstpt 0x14(%rsp)
fabs
fstpt (%rsp)
callq 0x41c0
movq %rax, %rcx
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
negq %rax
fldz
fldt 0x14(%rsp)
fxch %st(1)
fucomi %st(1), %st
seta %dil
leaq 0x1(%rsi), %r8
cmovbeq %rsi, %r8
cmovbeq %rcx, %rax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %rsi, %rcx
movq %rdx, %r9
sbbq $0x0, %r9
setb %r9b
cmovaeq %r8, %rax
xorl %r8d, %r8d
cmpq %rcx, %rsi
sbbq %rdx, %r8
setb %cl
andb %dil, %cl
movzbl %cl, %ecx
testb $0x1, %r9b
movl $0x2, %edx
cmovnel %ecx, %edx
fucompi %st(1), %st
fstp %st(0)
cmoval %ecx, %edx
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/main.cc
// Function: main
int main() {
#if defined _WIN32 && defined _DEBUG
    // check memory leak
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
    // handle signal
    signal(SIGINT, signalHandler);
    signal(SIGTERM, signalHandler);
    // game logic
    currentPage = new Intro();
    currentPage -> Start();
    delete currentPage;
    currentPage = new Tetris();
    currentPage -> Start();
    delete currentPage;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq -0x2c(%rip), %rbx       # 0x341c
movl $0x2, %edi
movq %rbx, %rsi
callq 0x3170
movl $0xf, %edi
movq %rbx, %rsi
callq 0x3170
movl $0x340, %edi            # imm = 0x340
callq 0x3130
movq %rax, %rbx
movq %rax, %rdi
callq 0x3594
movq %rbx, 0x8cca(%rip)      # 0xc148
movq %rbx, %rdi
callq 0x34ec
movq 0x8cbb(%rip), %rdi      # 0xc148
testq %rdi, %rdi
je 0x3498
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x430, %edi            # imm = 0x430
callq 0x3130
movq %rax, %rbx
movq %rax, %rdi
callq 0x3b76
movq %rbx, 0x8c94(%rip)      # 0xc148
movq %rbx, %rdi
callq 0x34ec
movq 0x8c85(%rip), %rdi      # 0xc148
testq %rdi, %rdi
je 0x34ce
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x34d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Page::Start()
void Page::Start() {
    long long int curr;
    long long int prev = Time::msec();
    long long int diff;
    Console::Clear();
    Console::SetEcho(false);
    Console::SetCursor(false);
    while (!exit) {
        curr = Time::msec();
        diff = curr - prev;
        Loop();
        if (diff >= interval) {
            Render();
            Console::Update();
            prev = curr - (diff - interval);
            ++frame;
        }
    }
    Console::Clear();
    Console::SetEcho(true);
    Console::SetCursor(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68d4
movq %rax, %r14
callq 0x701a
xorl %edi, %edi
callq 0x6f8e
xorl %edi, %edi
callq 0x6fcc
cmpb $0x0, 0x8(%rbx)
jne 0x3555
callq 0x68d4
movq %rax, %r15
subq %r14, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x354f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
callq 0x72a0
movslq 0x10(%rbx), %rax
addq %rax, %r14
incl 0xc(%rbx)
cmpb $0x1, 0x8(%rbx)
jne 0x351a
callq 0x701a
movl $0x1, %edi
callq 0x6f8e
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6fcc
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Intro::ResetParticle(int)
void Intro::ResetParticle(int index) {
    rotations[index] = random.Get(0, 100);
    rotateSpeeds[index] = random.Get(1, 5);
    falls[index] = random.Get(0, 100);
    fallSpeeds[index] = random.Get(5, 20);
    directions[index] = random.Get() < 0.5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x5f00
movslq %r15d, %r15
movl %eax, 0xd0(%rbx,%r15,4)
movq %r14, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x5f00
movl %eax, 0xf8(%rbx,%r15,4)
movq %r14, %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x5f00
movl %eax, 0x120(%rbx,%r15,4)
movq %r14, %rdi
movl $0x5, %esi
movl $0x14, %edx
callq 0x5f00
movl %eax, 0x148(%rbx,%r15,4)
movq %r14, %rdi
callq 0x5782
movsd 0x47f1(%rip), %xmm1     # 0x8008
ucomisd %xmm0, %xmm1
seta 0x170(%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Intro::RenderTitle(int, int)
void Intro::RenderTitle(int x, int y) {
    int xx;
    int yy;
    Screen* screen = Console::GetScreen();
    for (int i = 0; i < titleWidth; ++i) {
        for (int j = 0; j < titleHeight; ++j) {
            if (titleTable[j * titleWidth + i]) {
                xx = x + i;
                yy = y + j;
                screen -> FillCell(
                    ColorUtil::GetComplementary(
                        screen -> GetColor(xx, yy, true)),
                    xx, yy, true);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movl %esi, %r12d
movq %rdi, %r14
callq 0x6f80
movq %rax, %r15
addq $0x17a, %r14            # imm = 0x17A
movl %r12d, %eax
movq %rax, -0x38(%rbp)
xorl %ecx, %ecx
movq -0x38(%rbp), %rax
movq %rcx, -0x40(%rbp)
leal (%rcx,%rax), %r12d
xorl %ebx, %ebx
movl -0x2c(%rbp), %r13d
cmpb $0x1, (%r14,%rbx)
jne 0x3b47
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl $0x1, %ecx
callq 0x6ae4
decl %eax
xorl %esi, %esi
cmpl $0x8, %eax
ja 0x3b33
movl %eax, %eax
leaq 0x45ac(%rip), %rcx      # 0x80dc
movl (%rcx,%rax,4), %esi
movq %r15, %rdi
movl %r12d, %edx
movl %r13d, %ecx
movl $0x1, %r8d
callq 0x6bd0
incl %r13d
addq $0x40, %rbx
cmpq $0x1c0, %rbx            # imm = 0x1C0
jne 0x3b04
movq -0x40(%rbp), %rcx
incq %rcx
incq %r14
cmpq $0x40, %rcx
jne 0x3af2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::Tetris()
Tetris::Tetris() {
    this -> dropFrameInterval = 20;
    this -> attachFrameInterval = 20;
    this -> lastDrop = this -> frame;
    this -> pieceGenerator = new TGM2Randomizer();
    this -> backgroundColor = BLUE;
    this -> queueScreen = new Screen(
        Tetromino::size * 2, (Tetromino::size + 1) * pieceQueueSize);
    for (int i = 0; i < pieceQueueSize; ++i)
        this -> pieceQueue.push_back(pieceGenerator -> Get());
    this -> holdPieceScreen = new Screen(
        Tetromino::size * 2, Tetromino::size + 1);
    this -> currentPiece = this -> EmitPiece();
    this -> holdPiece = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movb $0x0, 0x8(%rdi)
movabsq $0x1100000000, %rax     # imm = 0x1100000000
movq %rax, 0xc(%rdi)
leaq 0x7d28(%rip), %rax      # 0xb8c8
movq %rax, (%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x53be
leaq 0x3d0(%r15), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x410(%r15)
movups %xmm0, 0x400(%r15)
movups %xmm0, 0x3f0(%r15)
movups %xmm0, 0x3e0(%r15)
movups %xmm0, 0x3d0(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x5a14
movabsq $0x1400000014, %rax     # imm = 0x1400000014
movq %rax, 0x14(%r15)
movl 0xc(%r15), %eax
movl %eax, 0x1c(%r15)
movl $0x50, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
callq 0x605e
movq %r12, 0x3c8(%r15)
movl $0x4, 0x3b0(%r15)
movl $0x20, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movl $0x8, %esi
movl $0x14, %edx
callq 0x69e8
movq %r12, 0x3b8(%r15)
movl $0x4, %r13d
leaq -0x30(%rbp), %r12
movq 0x3c8(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x30(%rbp)
movq 0x400(%r15), %rcx
movq 0x410(%r15), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x3ca2
movq %rax, (%rcx)
addq $0x8, 0x400(%r15)
jmp 0x3cad
movq %r14, %rdi
movq %r12, %rsi
callq 0x5cf6
decl %r13d
jne 0x3c6d
movl $0x20, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movl $0x8, %esi
movl $0x5, %edx
callq 0x69e8
movq %r12, 0x3c0(%r15)
movq %r15, %rdi
callq 0x5136
movabsq $-0x1fffffffd, %rcx     # imm = 0xFFFFFFFE00000003
movq %rcx, 0xc(%rax)
movq %rax, 0x420(%r15)
movq $0x0, 0x428(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d13
jmp 0x3d13
movq %rax, %r15
movq %r12, %rdi
callq 0x3110
jmp 0x3d2a
movq %rax, %r15
jmp 0x3d32
jmp 0x3d27
movq %rax, %r15
movq %r14, %rdi
callq 0x5ca8
movq %rbx, %rdi
callq 0x5458
movq %r15, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::EmitPiece(Tetromino*)
Tetromino* Tetris::EmitPiece(Tetromino* piece) {
    if (piece == NULL)
        piece = this -> NextPiece();
    piece -> x = (TetrisStage::width - Tetromino::size) / 2;
    piece -> y = -(Tetromino::size / 2);
    return piece;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
testq %rsi, %rsi
jne 0x3d53
callq 0x5136
movabsq $-0x1fffffffd, %rcx     # imm = 0xFFFFFFFE00000003
movq %rcx, 0xc(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::~Tetris()
Tetris::~Tetris() {
    delete this -> currentPiece;
    delete this -> pieceGenerator;
    for (int i = 0; i < pieceQueueSize; ++i)
        delete this -> pieceQueue[i];
    this -> pieceQueue.clear();
    delete this -> queueScreen;
    delete this -> holdPieceScreen;
    if (this -> holdPiece != NULL)
        delete this -> holdPiece;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x7b4f(%rip), %rax      # 0xb8c8
movq %rax, (%rdi)
movq 0x420(%rdi), %rdi
testq %rdi, %rdi
je 0x3d8e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x3c8(%rbx), %rdi
testq %rdi, %rdi
je 0x3da0
movq (%rdi), %rax
callq *0x8(%rax)
xorl %r14d, %r14d
movabsq $-0x400000000000000, %r15 # imm = 0xFC00000000000000
xorl %r12d, %r12d
movq 0x3e0(%rbx), %rcx
movq %rcx, %rax
subq 0x3e8(%rbx), %rax
sarq $0x3, %rax
leaq (%r12,%rax), %rdx
cmpq $0x3f, %rdx
ja 0x3dd4
addq %r14, %rcx
jmp 0x3e05
movq 0x3f8(%rbx), %rcx
movq %rdx, %rsi
shrq $0x6, %rsi
leaq (%rsi,%r15), %rdi
testq %rdx, %rdx
cmovgq %rsi, %rdi
movq %rdi, %rdx
shlq $0x6, %rdx
subq %rdx, %rax
addq %r12, %rax
shlq $0x3, %rax
addq (%rcx,%rdi,8), %rax
movq %rax, %rcx
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x3e13
movq (%rdi), %rax
callq *0x8(%rax)
incq %r12
addq $0x8, %r14
cmpq $0x4, %r12
jne 0x3db0
leaq 0x3d0(%rbx), %r14
movq %r14, %rdi
callq 0x5800
movq 0x3b8(%rbx), %r15
testq %r15, %r15
je 0x3e4b
movq %r15, %rdi
callq 0x6a1e
movq %r15, %rdi
callq 0x3110
movq 0x3c0(%rbx), %r15
testq %r15, %r15
je 0x3e67
movq %r15, %rdi
callq 0x6a1e
movq %r15, %rdi
callq 0x3110
movq 0x428(%rbx), %rdi
testq %rdi, %rdi
je 0x3e79
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x5ca8
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5458
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::ControlPiece(std::function<void ()>)
void Tetris::ControlPiece(std::function<void()> controlFunction) {
    Tetromino* trash;
    Tetromino* backup = currentPiece -> Clone();
    controlFunction();
    if (stage.CheckCollision(*currentPiece)) {
        trash = currentPiece;
        currentPiece = backup;
    }
    else {
        trash = backup;
    }
    delete trash;
    Infinity();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x420(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x10(%r15)
je 0x4329
movq %rax, %r14
movq %r15, %rdi
callq *0x18(%r15)
leaq 0x38(%rbx), %rdi
movq 0x420(%rbx), %rsi
callq 0x5270
testb %al, %al
je 0x4309
movq 0x420(%rbx), %rax
movq %r14, 0x420(%rbx)
movq %rax, %r14
testq %r14, %r14
je 0x4317
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5358
callq 0x3080
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::SoftDrop(bool)
bool Tetris::SoftDrop(bool attach) {
    ++(this -> currentPiece -> y);
    if (stage.CheckCollision(*currentPiece)) {
        --(this -> currentPiece -> y);
        if (attach)
            this -> AttachPiece();
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x420(%rdi), %rsi
incl 0x10(%rsi)
addq $0x38, %rdi
callq 0x5270
movl %eax, %r14d
testb %al, %al
je 0x436f
movq 0x420(%rbx), %rax
decl 0x10(%rax)
testb %r15b, %r15b
je 0x436f
movq %rbx, %rdi
callq 0x51aa
xorb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::HardDrop(bool)
void Tetris::HardDrop(bool attach) {
    int cast = stage.CastPiece(*currentPiece);
    statistics.score += 2 * cast;
    if (attach)
        AttachPiece();
    else
        Infinity();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x420(%rbx), %rsi
callq 0x5314
addl %eax, %eax
addl %eax, 0x20(%rbx)
movq %rbx, %rdi
testl %r14d, %r14d
je 0x43b5
popq %rbx
popq %r14
popq %rbp
jmp 0x51aa
popq %rbx
popq %r14
popq %rbp
jmp 0x5358
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::HoldPiece()
void Tetris::HoldPiece() {
    if (holdPiece == NULL) {
        holdPiece = currentPiece;
        currentPiece = this -> EmitPiece();
    }
    else {
        Tetromino* temp = currentPiece;
        currentPiece = this -> EmitPiece(holdPiece);
        holdPiece = temp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x420(%rdi), %rax
movq 0x428(%rdi), %rcx
testq %rcx, %rcx
je 0x43f8
movabsq $-0x1fffffffd, %rdx     # imm = 0xFFFFFFFE00000003
movq %rdx, 0xc(%rcx)
movq %rcx, 0x420(%rbx)
movq %rax, 0x428(%rbx)
jmp 0x441c
movq %rax, 0x428(%rbx)
movq %rbx, %rdi
callq 0x5136
movabsq $-0x1fffffffd, %rcx     # imm = 0xFFFFFFFE00000003
movq %rcx, 0xc(%rax)
movq %rax, 0x420(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::CheckGameOver()
bool Tetris::CheckGameOver() {
    for (int i = 0; i < TetrisStage::width; ++i)
        if (this -> stage.CheckBlock(i, 1))
            return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
cmpl $0x0, 0x60(%rdi)
jne 0x444d
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x9, %rcx
je 0x4446
leaq 0x1(%rax), %rcx
cmpl $0x0, 0x64(%rdi,%rax,4)
je 0x4432
cmpq $0x9, %rax
setb %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::CheckLine(int)
bool Tetris::CheckLine(int y) {
    for (int i = 0; i < TetrisStage::width; ++i)
        if (!(this -> stage.CheckBlock(i, y)))
            return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x15, %esi
ja 0x4491
leaq 0x38(%rdi), %rcx
movl %esi, %eax
leaq (%rax,%rax,4), %rax
cmpl $0x0, (%rcx,%rax,8)
je 0x4491
leaq (%rdi,%rax,8), %rcx
addq $0x3c, %rcx
xorl %edx, %edx
cmpq $0x9, %rdx
setae %al
cmpl $0x15, %esi
ja 0x4493
cmpq $0x8, %rdx
ja 0x4493
cmpl $0x0, (%rcx,%rdx,4)
leaq 0x1(%rdx), %rdx
jne 0x4473
jmp 0x4493
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::LevelUp()
void Tetris::LevelUp() {
    ++statistics.level;
    dropFrameInterval = max(dropFrameInterval - 1, 1);
    int color = (int) backgroundColor - 4;
    backgroundColor = (Color) ((++color % 6) + 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incl 0x24(%rdi)
movl 0x14(%rdi), %eax
cmpl $0x3, %eax
movl $0x2, %ecx
cmovgel %eax, %ecx
decl %ecx
movl %ecx, 0x14(%rdi)
movl 0x3b0(%rdi), %eax
leal -0x3(%rax), %ecx
movslq %ecx, %rcx
imulq $0x2aaaaaab, %rcx, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x3b0(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: TetrisStage::Render(Tetromino&, bool)
void TetrisStage::Render(Tetromino& piece, bool renderGhost) {
    this -> RenderStage();
    if (renderGhost)
        this -> RenderGhostPiece(piece);
    this -> RenderPiece(piece);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x54da
testl %r15d, %r15d
je 0x4e3a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x560c
movq 0x370(%r14), %rsi
movl 0xc(%rbx), %edx
addl %edx, %edx
movl 0x10(%rbx), %ecx
movq (%rbx), %rax
movq 0x30(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::RenderPieceQueue()
void Tetris::RenderPieceQueue() {
    int width = queueScreen -> GetWidth();
    int offset = Tetromino::size + 1;
    queueScreen -> Clear(' ', BLACK, BLACK);
    queueScreen -> WriteLine("NEXT", 0, 0);
    for (int i = 0; i < pieceQueueSize; ++i) {
        queueScreen -> FillLine(backgroundColor, 0, i * offset, width, true);
        (*pieceQueue[i]).Render(*queueScreen, 0, i * offset + 1);
    }
    queueScreen -> FillLine(WHITE, 0, 0, 4, true);
    queueScreen -> FillLine(BLACK, 0, 0, 4, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x3b8(%rdi), %rdi
callq 0x6a6a
movl %eax, %r14d
movq 0x3b8(%rbx), %rdi
movl $0x20, %esi
movl $0x3, %edx
movl $0x3, %ecx
callq 0x6df2
movq 0x3b8(%rbx), %r15
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3463(%rip), %rsi      # 0x8317
leaq 0x3460(%rip), %rdx      # 0x831b
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x5c0e
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6b50
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4ee4
callq 0x3110
movl $0x1, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x3b8(%rbx), %rdi
movl 0x3b0(%rbx), %esi
leal -0x1(%r15), %ecx
xorl %edx, %edx
movl %r14d, %r8d
movl $0x1, %r9d
callq 0x6c0a
movq 0x3e0(%rbx), %rcx
movq %rcx, %rax
subq 0x3e8(%rbx), %rax
sarq $0x3, %rax
leaq (%rax,%r13), %rdx
cmpq $0x3f, %rdx
ja 0x4f35
addq %r12, %rcx
jmp 0x4f6f
movq 0x3f8(%rbx), %rcx
movq %rdx, %rsi
shrq $0x6, %rsi
movabsq $-0x400000000000000, %rdi # imm = 0xFC00000000000000
addq %rsi, %rdi
testq %rdx, %rdx
cmovgq %rsi, %rdi
movq %rdi, %rdx
shlq $0x6, %rdx
subq %rdx, %rax
addq %r13, %rax
shlq $0x3, %rax
addq (%rcx,%rdi,8), %rax
movq %rax, %rcx
movq (%rcx), %rdi
movq 0x3b8(%rbx), %rsi
movq (%rdi), %rax
xorl %edx, %edx
movl %r15d, %ecx
callq *0x30(%rax)
incq %r13
addl $0x5, %r15d
addq $0x8, %r12
cmpq $0x4, %r13
jne 0x4ef0
movq 0x3b8(%rbx), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
movl $0x1, %r9d
callq 0x6c0a
movq 0x3b8(%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x6c0a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4ff8
callq 0x3110
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::RenderHoldPiece()
void Tetris::RenderHoldPiece() {
    holdPieceScreen -> Clear(' ', BLACK, BLACK);
    holdPieceScreen -> WriteLine("HOLD", 0, 0);
    holdPieceScreen -> FillLine(backgroundColor, 0, 0,
        holdPieceScreen -> GetWidth(), true);
    if (holdPiece != NULL)
        (*holdPiece).Render(*holdPieceScreen, 0, 1);
    holdPieceScreen -> FillLine(WHITE, 0, 0, 4, true);
    holdPieceScreen -> FillLine(BLACK, 0, 0, 4, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x3c0(%rdi), %rdi
movl $0x20, %esi
movl $0x3, %edx
movl $0x3, %ecx
callq 0x6df2
movq 0x3c0(%rbx), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x32d8(%rip), %rsi      # 0x831c
leaq 0x32d5(%rip), %rdx      # 0x8320
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x5c0e
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6b50
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5074
callq 0x3110
movq 0x3c0(%rbx), %r14
movl 0x3b0(%rbx), %r15d
movq %r14, %rdi
callq 0x6a6a
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl %eax, %r8d
movl $0x1, %r9d
callq 0x6c0a
movq 0x428(%rbx), %rdi
testq %rdi, %rdi
je 0x50c2
movq 0x3c0(%rbx), %rsi
movq (%rdi), %rax
xorl %edx, %edx
movl $0x1, %ecx
callq *0x30(%rax)
movq 0x3c0(%rbx), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
movl $0x1, %r9d
callq 0x6c0a
movq 0x3c0(%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x6c0a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x511f
callq 0x3110
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::NextPiece()
Tetromino* Tetris::NextPiece() {
    Tetromino* result;
    this -> pieceQueue.push_back(pieceGenerator -> Get());
    result = this -> pieceQueue.front();
    this -> pieceQueue.pop_front();
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x3d0(%rdi), %rbx
movq 0x3c8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x18(%rbp)
movq 0x400(%r14), %rcx
movq 0x410(%r14), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x5180
movq %rax, (%rcx)
addq $0x8, 0x400(%r14)
jmp 0x518c
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x5cf6
movq 0x3e0(%r14), %rax
movq (%rax), %r14
movq %rbx, %rdi
callq 0x5872
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: TetrisStage::AttachPiece(Tetromino&)
void TetrisStage::AttachPiece(Tetromino& piece) {
    for (int i = 0; i < Tetromino::size; ++i) {
        for (int j = 0; j < Tetromino::size; ++j) {
            if (piece.CheckBlock(i, j)) {
                int x = i + piece.x;
                int y = j + piece.y;
                this -> WriteBlock(piece.color, x, y);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq *0x28(%rax)
testb %al, %al
je 0x5254
movl 0xc(%rbx), %eax
addl %r15d, %eax
movl 0x10(%rbx), %ecx
addl %r12d, %ecx
cmpl $0xa, %eax
setae %dl
cmpl $0x16, %ecx
setae %sil
orb %dl, %sil
jne 0x5254
movl 0x8(%rbx), %edx
movl %ecx, %ecx
movl %eax, %eax
leaq (%rcx,%rcx,4), %rcx
leaq (%r14,%rcx,8), %rcx
movl %edx, (%rcx,%rax,4)
incl %r12d
cmpl $0x4, %r12d
jne 0x5211
incl %r15d
cmpl $0x4, %r15d
jne 0x520e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: TetrisStage::CheckCollision(Tetromino&)
bool TetrisStage::CheckCollision(Tetromino& piece) {
    for (int i = 0; i < Tetromino::size; ++i) {
        for (int j = 0; j < Tetromino::size; ++j) {
            if (piece.CheckBlock(i, j)) {
                int x = i + piece.x;
                int y = j + piece.y;
                if (this -> CheckOutOfRange(x, y) ||
                    this -> CheckBlock(x, y))
                    return true;
            }
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movb $0x1, -0x29(%rbp)
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq *0x28(%rax)
testb %al, %al
je 0x52ce
movl 0xc(%rbx), %eax
addl %r12d, %eax
cmpl $0x9, %eax
ja 0x52e4
movl 0x10(%rbx), %ecx
addl %r13d, %ecx
cmpl $0x15, %ecx
jg 0x52e4
ja 0x52ce
movl %ecx, %ecx
movl %eax, %eax
leaq (%rcx,%rcx,4), %rcx
leaq (%r14,%rcx,8), %rcx
cmpl $0x0, (%rcx,%rax,4)
jne 0x52e4
cmpl $0x3, %r13d
leal 0x1(%r13), %eax
setae %r15b
movl %eax, %r13d
cmpl $0x4, %eax
jne 0x5291
jmp 0x52ea
testb $0x1, %r15b
je 0x52ff
cmpl $0x3, %r12d
leal 0x1(%r12), %eax
setb -0x29(%rbp)
movl %eax, %r12d
cmpl $0x4, %eax
jne 0x528b
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: TetrisStage::CastPiece(Tetromino&)
int TetrisStage::CastPiece(Tetromino& piece) {
    int lineCount = 0;
    while (!(this -> CheckCollision(piece))) {
        ++piece.y;
        ++lineCount;
    }
    --piece.y;
    return lineCount - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5270
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testb %al, %al
jne 0x5346
incl 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5270
incl %r15d
jmp 0x532f
decl 0x10(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/disjukr[P]Tetris/Tetris.cc
// Function: Tetris::Infinity()
void Tetris::Infinity() {
    ++(currentPiece -> y);
    if (stage.CheckCollision(*currentPiece))
        lastDrop = frame;
    --(currentPiece -> y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x420(%rdi), %rsi
incl 0x10(%rsi)
addq $0x38, %rdi
callq 0x5270
testb %al, %al
je 0x537e
movl 0xc(%rbx), %eax
movl %eax, 0x1c(%rbx)
movq 0x420(%rbx), %rax
decl 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop