LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5444
cmpl $0x0, (%r12)
jle 0x53cc
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 0x53ad
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2100
leaq 0x8(%r14), %r15
movslq (%r12), %rsi
movq %r15, %rdi
callq 0x5444
cmpl $0x0, (%r12)
jle 0x5418
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 0x53f9
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_O3/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 0x138e(%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 0x57d4
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x1342(%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 0x57a1
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
callq 0x2330
leaq 0x12f4(%rip), %rsi      # 0x6ae3
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x5847
movl $0x1, %ebp
xorl %ecx, %ecx
leaq 0x12cf(%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 0x5814
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_O3/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 0x63f6
movl %eax, %ebx
callq 0x66dd
movl %eax, %ebp
andb %bl, %bpl
callq 0x69c4
movl %eax, %ebx
callq 0x6cab
movl %eax, %r14d
andb %bl, %r14b
andb %bpl, %r14b
callq 0x6f92
movl %eax, %ebx
callq 0x7279
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_O3/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 0x781a
testq %rcx, %rcx
setne %dl
testq %rsi, %rsi
setne %dil
testb %dl, %dil
jne 0x781f
addq %rsi, %rcx
jmp 0x7854
leaq (%rcx,%rsi), %rdx
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
testq %rcx, %rcx
js 0x7841
movq %rdi, %r8
subq %rcx, %r8
cmpq %rsi, %r8
cmovlq %rdi, %rdx
jmp 0x7851
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_O3/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), %rax
movq %rax, %rcx
xorq %rsi, %rcx
setns %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x7893
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
testq %rax, %rax
setne %dil
leaq 0x1(%rcx), %rdx
cmpq %rdx, %rsi
sete %r8b
orb %dil, %r8b
jne 0x789e
subq %rsi, %rax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
cmpq %rdx, %rsi
jne 0x78b3
leaq (%rax,%rcx), %rdx
testq %rax, %rax
cmovgq %rcx, %rdx
movq %rdx, (%rbx)
jmp 0x7899
negq %rsi
movq %rbx, %rdi
callq 0x77fa
jmp 0x7899
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7e1c
cmpl $0x1, %edx
je 0x78ed
cmpl $0x2, %edx
je 0x78f0
cmpl $0x3, %edx
je 0x78fe
movq %rax, %r14
jmp 0x78f0
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 0x11852(%rip), %rsi     # 0x19164
movq %rax, %rdi
callq 0x4540
movq 0x1e6bf(%rip), %rsi     # 0x25fe0
movq 0x1e6a8(%rip), %rdx     # 0x25fd0
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_O3/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 0x7efd
cmpl $0x1, %edx
je 0x7971
cmpl $0x2, %edx
je 0x7974
cmpl $0x3, %edx
je 0x7982
movq %rax, %r14
jmp 0x7974
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 0x117d7(%rip), %rsi     # 0x1916d
movq %rax, %rdi
callq 0x4540
movq 0x1e63b(%rip), %rsi     # 0x25fe0
movq 0x1e624(%rip), %rdx     # 0x25fd0
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_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
jns 0x79ff
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x7858
movq (%r12), %r15
testq %r14, %r14
js 0x7a0e
movq %r15, %rax
cqto
idivq %r14
jmp 0x7a45
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r13, (%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x7858
movq %r15, %rax
cqto
idivq (%r12)
movq %r13, (%r12)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x7858
movq (%r14), %rdx
movq %rdx, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7fe9
cmpl $0x1, %edx
je 0x7ba0
cmpl $0x2, %edx
je 0x7ba3
cmpl $0x3, %edx
je 0x7bae
movq %rax, %rbx
jmp 0x7ba3
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4180
movq %rax, %rbx
leaq 0x115b3(%rip), %rsi     # 0x19175
movq %rax, %rdi
callq 0x4540
movq 0x1e40f(%rip), %rsi     # 0x25fe0
movq 0x1e3f8(%rip), %rdx     # 0x25fd0
movq %rbx, %rdi
callq 0x44d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
movq %r14, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8385
shrq $0x4, %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rbx, %rcx
subq %rax, %rcx
jne 0x8385
testq %rbx, %rbx
je 0x838a
movl $0x3e8, %r14d           # imm = 0x3E8
movl $0x3e8, %eax            # imm = 0x3E8
leaq -0x3e8(%r14), %rsi
movq %rax, %rdi
callq 0x7e1c
cmpq %rbx, %r14
jge 0x8391
addq $0x3e8, %r14            # imm = 0x3E8
testl %edx, %edx
je 0x8364
jmp 0x8391
movq %rbx, %rax
jmp 0x8391
xorl %edx, %edx
movl $0x3e8, %eax            # imm = 0x3E8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %esi
cmpq $-0x7d1, %rcx           # imm = 0xF82F
jb 0x869a
subq $0x28, %rsp
movq %rax, 0x20(%rsp)
fildll 0x20(%rsp)
flds 0x10b67(%rip)           # 0x19160
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 0x10bb3(%rip)           # 0x191d0
fmulp %st, %st(1)
fld %st(0)
fstpt 0x14(%rsp)
fabs
fstpt (%rsp)
callq 0x41c0
movq %rax, %rcx
movq %rax, %rdi
shrq $0x3f, %rdi
xorl %r8d, %r8d
movq %rdi, %rax
orq %rdx, %rax
setne %r8b
xorl %eax, %eax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %rcx, %rsi
sbbq %rdx, %rax
setb %sil
movq %rcx, %rax
negq %rax
addl %r8d, %r8d
movabsq $0x7fffffffffffffff, %r9 # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%r9), %r10
fldz
fldt 0x14(%rsp)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
cmovbeq %r9, %r10
movzbl %sil, %esi
cmovbel %r8d, %esi
cmovbeq %rcx, %rax
orq %rdx, %rdi
cmovneq %r10, %rax
addq $0x28, %rsp
movl %esi, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %esi
cmpq $-0x7d1, %rcx           # imm = 0xF82F
jb 0x876d
subq $0x28, %rsp
movq %rax, 0x20(%rsp)
fildll 0x20(%rsp)
flds 0x10a94(%rip)           # 0x19160
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 0x10ae0(%rip)           # 0x191d0
fmulp %st, %st(1)
fld %st(0)
fstpt 0x14(%rsp)
fabs
fstpt (%rsp)
callq 0x41c0
movq %rax, %rcx
movq %rax, %rdi
shrq $0x3f, %rdi
xorl %r8d, %r8d
movq %rdi, %rax
orq %rdx, %rax
setne %r8b
xorl %eax, %eax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %rcx, %rsi
sbbq %rdx, %rax
setb %sil
movq %rcx, %rax
negq %rax
addl %r8d, %r8d
movabsq $0x7fffffffffffffff, %r9 # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%r9), %r10
fldz
fldt 0x14(%rsp)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
cmovbeq %r9, %r10
movzbl %sil, %esi
cmovbel %r8d, %esi
cmovbeq %rcx, %rax
orq %rdx, %rdi
cmovneq %r10, %rax
addq $0x28, %rsp
movl %esi, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x109dd(%rip)           # 0x19160
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 0x10a29(%rip)           # 0x191d0
fmulp %st, %st(1)
fld %st(0)
fstpt 0x14(%rsp)
fabs
fstpt (%rsp)
callq 0x41c0
movq %rax, %rsi
shrq $0x3f, %rsi
xorl %edi, %edi
movq %rsi, %rcx
orq %rdx, %rcx
setne %dil
xorl %ecx, %ecx
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
cmpq %rax, %r8
sbbq %rdx, %rcx
setb %cl
movq %rax, %r8
negq %r8
addl %edi, %edi
movabsq $0x7fffffffffffffff, %r9 # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%r9), %r10
fldz
fldt 0x14(%rsp)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
cmovbeq %r9, %r10
movzbl %cl, %ecx
cmovbel %edi, %ecx
cmovaq %r8, %rax
orq %rdx, %rsi
cmovneq %r10, %rax
movl %ecx, %edx
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67f8
movq %rax, %r14
callq 0x6f46
xorl %edi, %edi
callq 0x6eba
xorl %edi, %edi
callq 0x6ef8
cmpb $0x0, 0x8(%rbx)
jne 0x3555
callq 0x67f8
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 0x71cc
movslq 0x10(%rbx), %rax
addq %rax, %r14
incl 0xc(%rbx)
cmpb $0x1, 0x8(%rbx)
jne 0x351a
callq 0x6f46
movl $0x1, %edi
callq 0x6eba
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6ef8
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e98
movslq %r15d, %r15
movl %eax, 0xd0(%rbx,%r15,4)
movq %r14, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x5e98
movl %eax, 0xf8(%rbx,%r15,4)
movq %r14, %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x5e98
movl %eax, 0x120(%rbx,%r15,4)
movq %r14, %rdi
movl $0x5, %esi
movl $0x14, %edx
callq 0x5e98
movl %eax, 0x148(%rbx,%r15,4)
movq %r14, %rdi
callq 0x570a
movsd 0x47f7(%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_O3/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)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
callq 0x6eac
movq %rax, %r12
addq $0x17a, %r15            # imm = 0x17A
xorl %ecx, %ecx
movq -0x38(%rbp), %rax
movq %rcx, -0x40(%rbp)
leal (%rcx,%rax), %r13d
xorl %r14d, %r14d
movl -0x2c(%rbp), %ebx
cmpb $0x1, (%r15,%r14)
jne 0x3b3d
movq %r12, %rdi
movl %r13d, %esi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x6a04
decl %eax
xorl %esi, %esi
cmpl $0x8, %eax
ja 0x3b2a
movl %eax, %eax
leaq 0x45b5(%rip), %rcx      # 0x80dc
movl (%rcx,%rax,4), %esi
movq %r12, %rdi
movl %r13d, %edx
movl %ebx, %ecx
movl $0x1, %r8d
callq 0x6af0
incl %ebx
addq $0x40, %r14
cmpq $0x1c0, %r14            # imm = 0x1C0
jne 0x3afc
movq -0x40(%rbp), %rcx
incq %rcx
incq %r15
cmpq $0x40, %rcx
jne 0x3aea
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7d7a(%rip), %rax      # 0xb910
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 0x534e
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 0x599c
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 0x5fe6
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 0x6904
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 0x3c98
movq %rax, (%rcx)
addq $0x8, 0x400(%r15)
jmp 0x3ca3
movq %r14, %rdi
movq %r12, %rsi
callq 0x5c8e
decl %r13d
jne 0x3c63
movl $0x20, %edi
callq 0x3130
movq %rax, %r12
movq %rax, %rdi
movl $0x8, %esi
movl $0x5, %edx
callq 0x6904
movq %r12, 0x3c0(%r15)
movq %r15, %rdi
callq 0x50dc
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 0x3d09
jmp 0x3d09
movq %rax, %r15
movq %r12, %rdi
callq 0x3110
jmp 0x3d20
movq %rax, %r15
jmp 0x3d28
jmp 0x3d1d
movq %rax, %r15
movq %r14, %rdi
callq 0x5c34
movq %rbx, %rdi
callq 0x53e8
movq %r15, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d49
callq 0x50dc
movabsq $-0x1fffffffd, %rcx     # imm = 0xFFFFFFFE00000003
movq %rcx, 0xc(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7ba2(%rip), %rax      # 0xb910
movq %rax, (%rdi)
movq 0x420(%rdi), %rdi
testq %rdi, %rdi
je 0x3d83
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x3c8(%rbx), %rdi
testq %rdi, %rdi
je 0x3d95
movq (%rdi), %rax
callq *0x8(%rax)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x3e0(%rbx), %rdx
movq 0x3f8(%rbx), %rcx
movq %rdx, %rax
subq 0x3e8(%rbx), %rax
sarq $0x3, %rax
addq %r15, %rax
js 0x3dca
cmpq $0x3f, %rax
ja 0x3dd3
addq %r14, %rdx
movq %rdx, %rax
jmp 0x3dec
movq %rax, %rdx
sarq $0x6, %rdx
jmp 0x3dda
movq %rax, %rdx
shrq $0x6, %rdx
movq %rdx, %rsi
shlq $0x6, %rsi
subq %rsi, %rax
shlq $0x3, %rax
addq (%rcx,%rdx,8), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3dfa
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
addq $0x8, %r14
cmpq $0x4, %r15
jne 0x3d9b
leaq 0x3d0(%rbx), %r14
movq %r14, %rdi
callq 0x5788
movq 0x3b8(%rbx), %r15
testq %r15, %r15
je 0x3e2a
movq %r15, %rdi
callq 0x693a
movq %r15, %rdi
callq 0x3110
movq 0x3c0(%rbx), %r15
testq %r15, %r15
je 0x3e46
movq %r15, %rdi
callq 0x693a
movq %r15, %rdi
callq 0x3110
movq 0x428(%rbx), %rdi
testq %rdi, %rdi
je 0x3e60
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x5c34
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x53e8
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42ed
movq %rax, %r14
movq %r15, %rdi
callq *0x18(%r15)
leaq 0x38(%rbx), %rdi
movq 0x420(%rbx), %rsi
callq 0x5216
testb %al, %al
je 0x42cd
movq 0x420(%rbx), %rax
movq %r14, 0x420(%rbx)
movq %rax, %r14
testq %r14, %r14
je 0x42db
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x52e8
callq 0x3080
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5216
movl %eax, %r14d
testb %al, %al
je 0x4333
movq 0x420(%rbx), %rax
decl 0x10(%rax)
testb %r15b, %r15b
je 0x4333
movq %rbx, %rdi
callq 0x5150
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_O3/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 0x52a4
addl %eax, %eax
addl %eax, 0x20(%rbx)
movq %rbx, %rdi
testl %r14d, %r14d
je 0x4379
popq %rbx
popq %r14
popq %rbp
jmp 0x5150
popq %rbx
popq %r14
popq %rbp
jmp 0x52e8
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43bc
movabsq $-0x1fffffffd, %rdx     # imm = 0xFFFFFFFE00000003
movq %rdx, 0xc(%rcx)
movq %rcx, 0x420(%rbx)
movq %rax, 0x428(%rbx)
jmp 0x43e0
movq %rax, 0x428(%rbx)
movq %rbx, %rdi
callq 0x50dc
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_O3/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 0x4411
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x9, %rcx
je 0x440a
leaq 0x1(%rax), %rcx
cmpl $0x0, 0x64(%rdi,%rax,4)
je 0x43f6
cmpq $0x9, %rax
setb %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
jbe 0x4421
xorl %eax, %eax
jmp 0x4446
movl %esi, %eax
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %rcx
addq $0x38, %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
testl %esi, %esi
setne %al
cmpq $0x8, %rdx
ja 0x4446
incq %rdx
testl %esi, %esi
jne 0x4431
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5462
testl %r15d, %r15d
je 0x4dec
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5594
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_O3/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 0x698a
movl %eax, %r14d
movq 0x3b8(%rbx), %rdi
movl $0x20, %esi
movl $0x3, %edx
movl $0x3, %ecx
callq 0x6d1e
movq 0x3b8(%rbx), %r15
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x34b1(%rip), %rsi      # 0x8317
leaq 0x34ae(%rip), %rdx      # 0x831b
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x5b96
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6a70
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4e96
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 0x6b2a
movq 0x3e0(%rbx), %rdx
movq 0x3f8(%rbx), %rcx
movq %rdx, %rax
subq 0x3e8(%rbx), %rax
sarq $0x3, %rax
addq %r13, %rax
js 0x4ef2
cmpq $0x3f, %rax
ja 0x4efb
addq %r12, %rdx
movq %rdx, %rax
jmp 0x4f14
movq %rax, %rdx
sarq $0x6, %rdx
jmp 0x4f02
movq %rax, %rdx
shrq $0x6, %rdx
movq %rdx, %rsi
shlq $0x6, %rsi
subq %rsi, %rax
shlq $0x3, %rax
addq (%rcx,%rdx,8), %rax
movq (%rax), %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 0x4ea2
movq 0x3b8(%rbx), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
movl $0x1, %r9d
callq 0x6b2a
movq 0x3b8(%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x6b2a
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 0x4f9d
callq 0x3110
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d1e
movq 0x3c0(%rbx), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3332(%rip), %rsi      # 0x831c
leaq 0x332f(%rip), %rdx      # 0x8320
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x5b96
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6a70
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x501a
callq 0x3110
movq 0x3c0(%rbx), %r14
movl 0x3b0(%rbx), %r15d
movq %r14, %rdi
callq 0x698a
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl %eax, %r8d
movl $0x1, %r9d
callq 0x6b2a
movq 0x428(%rbx), %rdi
testq %rdi, %rdi
je 0x5068
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 0x6b2a
movq 0x3c0(%rbx), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x6b2a
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 0x50c5
callq 0x3110
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5126
movq %rax, (%rcx)
addq $0x8, 0x400(%r14)
jmp 0x5132
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x5c8e
movq 0x3e0(%r14), %rax
movq (%rax), %r14
movq %rbx, %rdi
callq 0x57fa
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x51fa
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 0x51fa
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 0x51b7
incl %r15d
cmpl $0x4, %r15d
jne 0x51b4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb $0x1, %bl
xorl %r13d, %r13d
movq (%r14), %rax
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq *0x28(%rax)
testb %al, %al
je 0x5271
movl 0xc(%r14), %eax
addl %r12d, %eax
cmpl $0x9, %eax
ja 0x5290
movl 0x10(%r14), %ecx
addl %r13d, %ecx
cmpl $0x15, %ecx
jg 0x5290
ja 0x5271
movl %ecx, %ecx
movl %eax, %eax
leaq (%rcx,%rcx,4), %rcx
leaq (%r15,%rcx,8), %rcx
cmpl $0x0, (%rcx,%rax,4)
jne 0x5290
incl %r13d
cmpl $0x4, %r13d
jne 0x5232
cmpl $0x3, %r12d
leal 0x1(%r12), %eax
setb %bl
movl %eax, %r12d
cmpl $0x4, %eax
jne 0x522f
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5216
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testb %al, %al
jne 0x52d6
incl 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5216
incl %r15d
jmp 0x52bf
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_O3/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 0x5216
testb %al, %al
je 0x530e
movl 0xc(%rbx), %eax
movl %eax, 0x1c(%rbx)
movq 0x420(%rbx), %rax
decl 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/disjukr[P]Tetris/Tetris.cc
// Function: TetrisStage::TetrisStage()
TetrisStage::TetrisStage() {
    for (int i = 0; i < width; ++i)
        for (int j = 0; j < height; ++j)
            WriteBlock(NONE, i, j);
    this -> screen = new Screen(width * 2, height);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rdi, %rcx
movq $-0x370, %rdx           # imm = 0xFC90
movl $0x0, 0x370(%rcx,%rdx)
addq $0x28, %rdx
jne 0x5364
incq %rax
addq $0x4, %rcx
cmpq $0xa, %rax
jne 0x535d
movl $0x20, %edi
callq 0x3130
movq %rax, %r14
movq %rax, %rdi
movl $0x14, %esi
movl $0x16, %edx
callq 0x6904
movq %r14, 0x370(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/disjukr[P]Tetris/Tetris.cc
// Function: TetrisStage::RenderStage()
void TetrisStage::RenderStage() {
    // render map
    for (int i = 0; i < width; ++i) {
        for (int j = 0; j < height; ++j) {
            Color color = this -> ReadBlock(i, j);
            int x = i * 2;
            int y = j;
            color = color == NONE ? BLACK : color;
            this -> screen -> FillCell(color, x, y, true);
            this -> screen -> FillCell(color, x + 1, y, true);
        }
    }
    // render dead line
    this -> screen -> WriteLine("____________________", 0, 1);
    this -> screen -> FillLine(RED, 0, 1, width * 2, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl $0x3, %ecx
movq %rdi, %r14
leal (%rax,%rax), %edx
movl %edx, -0x2c(%rbp)
movq %rax, -0x40(%rbp)
leal 0x1(,%rax,2), %r15d
movq %r14, -0x38(%rbp)
xorl %r12d, %r12d
movl (%r14), %r13d
testl %r13d, %r13d
cmovel %ecx, %r13d
movq 0x370(%rbx), %rdi
movl %r13d, %esi
movl -0x2c(%rbp), %edx
movl %r12d, %ecx
movl $0x1, %r8d
callq 0x6af0
movq 0x370(%rbx), %rdi
movl %r13d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl $0x1, %r8d
callq 0x6af0
movl $0x3, %ecx
incq %r12
addq $0x28, %r14
cmpq $0x16, %r12
jne 0x5499
movq -0x40(%rbp), %rax
incq %rax
movq -0x38(%rbp), %r14
addq $0x4, %r14
cmpq $0xa, %rax
jne 0x5480
movq 0x370(%rbx), %r14
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2e0a(%rip), %rsi      # 0x8321
leaq 0x2e17(%rip), %rdx      # 0x8335
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x5b96
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x6a70
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x554a
callq 0x3110
movq 0x370(%rbx), %rdi
movl $0x8, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x14, %r8d
xorl %r9d, %r9d
callq 0x6b2a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x558b
callq 0x3110
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/disjukr[P]Tetris/Randomizer.cc
// Function: PieceGenerator::Get()
Tetromino* PieceGenerator::Get() {
    switch (this -> random.Get(0, 6)) {
    case 0: return new IMino();
    case 1: return new OMino();
    case 2: return new TMino();
    case 3: return new SMino();
    case 4: return new ZMino();
    case 5: return new JMino();
    default: return new LMino();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x18(%rax)
mulsd 0x2557(%rip), %xmm0     # 0x8470
callq 0x3200
cvttsd2si %xmm0, %ebx
movl $0x18, %edi
callq 0x3130
movq $0x0, 0xc(%rax)
cmpl $0x5, %ebx
ja 0x5fc6
leaq 0x253c(%rip), %rcx      # 0x8480
movslq (%rcx,%rbx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x5bbc(%rip), %rcx      # 0xbb10
movq %rcx, (%rax)
movb $0x1, 0x14(%rax)
movl $0x5, %ecx
jmp 0x5fdb
leaq 0x5d37(%rip), %rcx      # 0xbca0
movq %rcx, (%rax)
movb $0x1, 0x14(%rax)
movl $0x8, %ecx
jmp 0x5fdb
leaq 0x5c62(%rip), %rcx      # 0xbbe0
movq %rcx, (%rax)
movw $0x101, 0x14(%rax)      # imm = 0x101
movl $0x7, %ecx
jmp 0x5fdb
leaq 0x5cab(%rip), %rcx      # 0xbc40
movq %rcx, (%rax)
movb $0x1, 0x14(%rax)
movl $0x6, %ecx
jmp 0x5fdb
leaq 0x5bd6(%rip), %rcx      # 0xbb80
movq %rcx, (%rax)
jmp 0x5fd6
leaq 0x5d4a(%rip), %rcx      # 0xbd00
movq %rcx, (%rax)
movw $0x101, 0x14(%rax)      # imm = 0x101
movl $0x4, %ecx
jmp 0x5fdb
leaq 0x5d93(%rip), %rcx      # 0xbd60
movq %rcx, (%rax)
movw $0x101, 0x14(%rax)      # imm = 0x101
movl $0x9, %ecx
movl %ecx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/disjukr[P]Tetris/Randomizer.cc
// Function: TGM2Randomizer::TGM2Randomizer()
TGM2Randomizer::TGM2Randomizer() {
    history[0] = Z;
    history[1] = S;
    history[2] = Z;
    history[3] = S;
    first = true;
    pos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5a59(%rip), %rax      # 0xba50
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x59fb(%rip), %r14      # 0xba00
movq %r14, 0x8(%rbx)
movl $0xabcdef, %esi         # imm = 0xABCDEF
callq 0x5874
leaq 0x5a5e(%rip), %rax      # 0xba78
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
movq %r14, 0x20(%rbx)
movl $0xabcdef, %esi         # imm = 0xABCDEF
callq 0x5874
movabsq $0x600000005, %rax      # imm = 0x600000005
movq %rax, 0x44(%rbx)
movl $0x5, 0x4c(%rbx)
movb $0x1, 0x38(%rbx)
movabsq $0x600000000, %rax      # imm = 0x600000000
movq %rax, 0x3c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/disjukr[P]Tetris/Randomizer.cc
// Function: TGM2Randomizer::CheckHistory(int)
bool TGM2Randomizer::CheckHistory(int pieceType) {
    for (int i = 0; i < historySize; ++i)
        if (pieceType == history[i])
            return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
cmpl %esi, 0x40(%rdi)
je 0x6093
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x3, %rcx
je 0x608c
leaq 0x1(%rax), %rcx
cmpl %esi, 0x44(%rdi,%rax,4)
jne 0x6079
cmpq $0x3, %rax
setb %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/disjukr[P]Tetris/Randomizer.cc
// Function: TGM2Randomizer::Get()
Tetromino* TGM2Randomizer::Get() {
    int type = random.Get(0, first ? 3 : 6); // exclude O, S, Z
    first = false;
    int i = 0;
    while (this -> CheckHistory(type) && i++ < tryCount)
        type = random.Get(0, 6);
    history[pos] = type;
    pos = (pos + 1) % 4;
    switch (type) {
    case I: return new IMino();
    case O: return new OMino();
    case T: return new TMino();
    case S: return new SMino();
    case Z: return new ZMino();
    case J: return new JMino();
    default: return new LMino();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x20(%rdi), %rax
cmpb $0x0, 0x38(%rdi)
movsd 0x23b4(%rip), %xmm0     # 0x8470
je 0x60c6
movsd 0x23b2(%rip), %xmm0     # 0x8478
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
callq *0x18(%rax)
mulsd -0x28(%rbp), %xmm0
callq 0x3200
movb $0x0, 0x38(%rbx)
xorl %r12d, %r12d
cvttsd2si %xmm0, %r15d
movb $0x1, %al
cmpl %r15d, 0x40(%rbx)
je 0x610c
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x3, %rcx
je 0x6105
leaq 0x1(%rax), %rcx
cmpl %r15d, 0x44(%rbx,%rax,4)
jne 0x60f1
cmpq $0x3, %rax
setb %al
testb %al, %al
je 0x6131
cmpl $0x5, %r12d
ja 0x6131
incl %r12d
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
mulsd 0x2346(%rip), %xmm0     # 0x8470
callq 0x3200
jmp 0x60e2
movslq 0x3c(%rbx), %rax
movl %r15d, 0x40(%rbx,%rax,4)
movl 0x3c(%rbx), %eax
leal 0x1(%rax), %ecx
leal 0x4(%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
andl $-0x4, %edx
negl %edx
addl %edx, %eax
incl %eax
movl %eax, 0x3c(%rbx)
movl $0x18, %edi
callq 0x3130
movq $0x0, 0xc(%rax)
cmpl $0x6, %r15d
ja 0x61c0
movl %r15d, %ecx
leaq 0x2322(%rip), %rdx      # 0x8498
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x598a(%rip), %rcx      # 0xbb10
movq %rcx, (%rax)
movb $0x1, 0x14(%rax)
movl $0x5, %ecx
jmp 0x620d
leaq 0x5b65(%rip), %rcx      # 0xbd00
movq %rcx, (%rax)
movw $0x101, 0x14(%rax)      # imm = 0x101
movl $0x4, %ecx
jmp 0x620d
leaq 0x5aee(%rip), %rcx      # 0xbca0
movq %rcx, (%rax)
movb $0x1, 0x14(%rax)
movl $0x8, %ecx
jmp 0x620d
leaq 0x5b99(%rip), %rcx      # 0xbd60
movq %rcx, (%rax)
movw $0x101, 0x14(%rax)      # imm = 0x101
jmp 0x61f3
leaq 0x5a07(%rip), %rcx      # 0xbbe0
movq %rcx, (%rax)
movw $0x101, 0x14(%rax)      # imm = 0x101
movl $0x7, %ecx
jmp 0x620d
leaq 0x5990(%rip), %rcx      # 0xbb80
movq %rcx, (%rax)
movl $0x9, %ecx
jmp 0x620d
leaq 0x5a3f(%rip), %rcx      # 0xbc40
movq %rcx, (%rax)
movb $0x1, 0x14(%rax)
movl $0x6, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/disjukr[P]Tetris/./Tetromino.hh
// Function: IMino::CheckBlock(int, int)
virtual bool CheckBlock(int x, int y) {
        if (!Tetromino::CheckBlock(x, y))
            return false;
        if (vertical)
            return x == 1;
        else
            return y == 2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
orl %esi, %eax
cmpl $0x3, %eax
ja 0x6290
cmpb $0x1, 0x14(%rdi)
jne 0x6294
cmpl $0x1, %esi
jmp 0x6297
xorl %eax, %eax
jmp 0x629a
cmpl $0x2, %edx
sete %al
popq %rbp
retq