LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
cmpq $0x3e8, -0x18(%rbp)     # imm = 0x3E8
jg 0xb873
cmpq $-0x3e8, -0x18(%rbp)    # imm = 0xFC18
jge 0xb893
movq -0x18(%rbp), %rdi
callq 0xb080
movl %edx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xb908
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
fildll -0x78(%rbp)
flds 0x208bc(%rip)           # 0x2c160
fld %st(0)
fstpt -0x8c(%rbp)
fdivrp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0xc110
movq %rsp, %rax
fstpt (%rax)
callq 0x5040
fldt -0x8c(%rbp)
fmulp %st, %st(1)
fldt 0x20910(%rip)           # 0x2c1e0
fmulp %st, %st(1)
fstpt -0x60(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xc040
movq -0x80(%rbp), %rdi
callq 0xaee0
movl %edx, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
fildll -0x68(%rbp)
flds 0x20820(%rip)           # 0x2c160
fld %st(0)
fstpt -0x7c(%rbp)
fdivrp %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
callq 0xc140
movq %rsp, %rax
fstpt (%rax)
callq 0x5040
fldt -0x7c(%rbp)
fmulp %st, %st(1)
fldt 0x2087a(%rip)           # 0x2c1e0
fmulp %st, %st(1)
fstpt -0x50(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xc040
movq -0x70(%rbp), %rdi
callq 0xaee0
movl %edx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x90, %rsp
popq %rbp
retq
nop
// File: disjukr[P]Tetris/main.cc
// Function: signalHandler(int)
void signalHandler(int sig) {
    switch (sig) {
    case SIGINT: case SIGTERM:
        currentPage -> Exit();
        break;
    default: break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
je 0x34b2
jmp 0x34a8
movl -0x8(%rbp), %eax
subl $0xf, %eax
jne 0x34c1
jmp 0x34b2
movq 0xecb7(%rip), %rdi      # 0x12170
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x34c3
jmp 0x34c3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x56(%rip), %rsi       # 0x3490
movq %rsi, -0x28(%rbp)
movl $0x2, %edi
callq 0x31a0
movq -0x28(%rbp), %rsi
movl $0xf, %edi
callq 0x31a0
movl $0x340, %edi            # imm = 0x340
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x3700
jmp 0x351d
movq -0x20(%rbp), %rax
movq %rax, 0xec48(%rip)      # 0x12170
movq 0xec41(%rip), %rdi      # 0x12170
callq 0x35e0
movq 0xec35(%rip), %rax      # 0x12170
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x354f
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x430, %edi            # imm = 0x430
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x3fa0
jmp 0x356a
movq -0x38(%rbp), %rax
movq %rax, 0xebfb(%rip)      # 0x12170
movq 0xebf4(%rip), %rdi      # 0x12170
callq 0x35e0
movq 0xebe8(%rip), %rax      # 0x12170
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x359c
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3120
jmp 0x35d0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3120
movq -0x10(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xa870
movq %rax, -0x18(%rbp)
callq 0xb230
xorl %edi, %edi
callq 0xb180
xorl %edi, %edi
callq 0xb1d0
movq -0x28(%rbp), %rax
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x361f
jmp 0x3683
callq 0xa870
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq 0x10(%rcx), %rcx
cmpq %rcx, %rax
jl 0x3681
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
callq 0xb4c0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movslq 0x10(%rax), %rsi
subq %rsi, %rdx
subq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x3610
callq 0xb230
movl $0x1, %edi
callq 0xb180
movl $0x1, %edi
callq 0xb1d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x8f80
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movslq -0xc(%rbp), %rax
movl %ecx, 0xd0(%rdi,%rax,4)
addq $0x18, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x8f80
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movslq -0xc(%rbp), %rax
movl %ecx, 0xf8(%rdi,%rax,4)
addq $0x18, %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x8f80
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movslq -0xc(%rbp), %rax
movl %ecx, 0x120(%rdi,%rax,4)
addq $0x18, %rdi
movl $0x5, %esi
movl $0x14, %edx
callq 0x8f80
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movslq -0xc(%rbp), %rax
movl %ecx, 0x148(%rdi,%rax,4)
addq $0x18, %rdi
callq 0x7010
movq -0x18(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x850f(%rip), %xmm0     # 0xc008
ucomisd %xmm1, %xmm0
seta %dl
movslq -0xc(%rbp), %rcx
andb $0x1, %dl
movb %dl, 0x170(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xb170
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x40, -0x24(%rbp)
jge 0x3f94
movl $0x0, -0x28(%rbp)
cmpl $0x7, -0x28(%rbp)
jge 0x3f84
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %ecx
shll $0x6, %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
testb $0x1, 0x17a(%rax,%rcx)
je 0x3f77
movl -0xc(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x1, %ecx
callq 0xaca0
movl %eax, %edi
callq 0x70d0
movq -0x38(%rbp), %rdi
movl %eax, %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl $0x1, %r8d
callq 0xadc0
jmp 0x3f79
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3f0b
jmp 0x3f86
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3efa
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x420c
movq -0x18(%rbp), %rdi
callq 0x5a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0xfffffffe, 0x10(%rax) # imm = 0xFFFFFFFE
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xd665(%rip), %rcx      # 0x118b0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x420(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x426d
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x3c8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x428c
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x42d1
movq -0x20(%rbp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
movslq -0xc(%rbp), %rsi
callq 0x7260
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x42c4
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x42c6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4293
movq -0x20(%rbp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
callq 0x7290
movq -0x20(%rbp), %rax
movq 0x3b8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4308
movq -0x38(%rbp), %rdi
callq 0xaae0
movq -0x38(%rbp), %rdi
callq 0x3120
movq -0x20(%rbp), %rax
movq 0x3c0(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x432f
movq -0x40(%rbp), %rdi
callq 0xaae0
movq -0x40(%rbp), %rdi
callq 0x3120
movq -0x20(%rbp), %rax
cmpq $0x0, 0x428(%rax)
je 0x435e
movq -0x20(%rbp), %rax
movq 0x428(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x435c
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x435e
movq -0x20(%rbp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
callq 0x71f0
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x5ee0
movq -0x20(%rbp), %rdi
callq 0x7530
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x420(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x74b0
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq 0x420(%rax), %rsi
callq 0x5c00
testb $0x1, %al
jne 0x4823
jmp 0x483f
movq -0x28(%rbp), %rax
movq 0x420(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x420(%rax)
jmp 0x4847
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x485f
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x5d40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x420(%rax), %rcx
movl 0x10(%rcx), %edx
addl $0x1, %edx
movl %edx, 0x10(%rcx)
movq %rax, %rdi
addq $0x38, %rdi
movq 0x420(%rax), %rsi
callq 0x5c00
testb $0x1, %al
jne 0x4af5
jmp 0x4b1e
movq -0x20(%rbp), %rax
movq 0x420(%rax), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
testb $0x1, -0x11(%rbp)
je 0x4b18
movq -0x20(%rbp), %rdi
callq 0x5af0
movb $0x0, -0x1(%rbp)
jmp 0x4b22
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, %rdi
addq $0x38, %rdi
movq 0x420(%rax), %rsi
callq 0x5cd0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
shll %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
testb $0x1, -0x9(%rbp)
je 0x4b84
movq -0x18(%rbp), %rdi
callq 0x5af0
jmp 0x4b8d
movq -0x18(%rbp), %rdi
callq 0x5d40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x428(%rax)
jne 0x4be9
movq -0x18(%rbp), %rdi
movq 0x420(%rdi), %rax
movq %rax, 0x428(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x41e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x420(%rax)
jmp 0x4c1d
movq -0x18(%rbp), %rdi
movq 0x420(%rdi), %rax
movq %rax, -0x10(%rbp)
movq 0x428(%rdi), %rsi
callq 0x41e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x420(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x428(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x4c7f
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x5db0
testb $0x1, %al
jne 0x4c6c
jmp 0x4c72
movb $0x1, -0x1(%rbp)
jmp 0x4c83
jmp 0x4c74
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c4b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x4cde
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x5db0
testb $0x1, %al
jne 0x4cd1
movb $0x0, -0x1(%rbp)
jmp 0x4ce2
jmp 0x4cd3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4cae
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x74f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x14(%rax)
movl 0x3b0(%rax), %eax
subl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x6, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
addl $0x4, %edx
movl %edx, 0x3b0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6010
testb $0x1, -0x11(%rbp)
je 0x5717
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x61b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6220
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x3b8(%rax), %rdi
callq 0xabb0
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl $0x5, -0x10(%rbp)
movq 0x3b8(%rax), %rdi
movl $0x20, %esi
movl $0x3, %ecx
movl %ecx, %edx
callq 0xaf90
movq -0x60(%rbp), %rax
movq 0x3b8(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3280
movq -0x50(%rbp), %rdx
leaq 0x6bb5(%rip), %rsi      # 0xc354
leaq -0x30(%rbp), %rdi
callq 0x31d0
jmp 0x57aa
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0xad40
jmp 0x57bd
leaq -0x30(%rbp), %rdi
callq 0x30c0
leaq -0x31(%rbp), %rdi
callq 0x3170
movl $0x0, -0x48(%rbp)
cmpl $0x4, -0x48(%rbp)
jge 0x5879
movq -0x60(%rbp), %rax
movq 0x3b8(%rax), %rdi
movl 0x3b0(%rax), %esi
movl -0x48(%rbp), %ecx
imull -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
xorl %edx, %edx
movl $0x1, %r9d
callq 0xae20
movq -0x60(%rbp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
movslq -0x48(%rbp), %rsi
callq 0x7260
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq (%rcx), %rdi
movq 0x3b8(%rax), %rsi
movl -0x48(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl $0x1, %ecx
movq (%rdi), %rax
xorl %edx, %edx
callq *0x30(%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x57d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x586e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30c0
leaq -0x31(%rbp), %rdi
callq 0x3170
jmp 0x58c6
movq -0x60(%rbp), %rax
movq 0x3b8(%rax), %rdi
movl $0x1, %r9d
xorl %ecx, %ecx
movl $0x4, %r8d
movl %r9d, %esi
movl %ecx, %edx
callq 0xae20
movq -0x60(%rbp), %rax
movq 0x3b8(%rax), %rdi
movl $0x3, %esi
xorl %r9d, %r9d
movl $0x4, %r8d
movl %r9d, %edx
movl %r9d, %ecx
callq 0xae20
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3270
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x3c0(%rax), %rdi
movl $0x20, %esi
movl $0x3, %ecx
movl %ecx, %edx
callq 0xaf90
movq -0x58(%rbp), %rax
movq 0x3c0(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3280
movq -0x48(%rbp), %rdx
leaq 0x6a36(%rip), %rsi      # 0xc359
leaq -0x28(%rbp), %rdi
callq 0x31d0
jmp 0x592e
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0xad40
jmp 0x5941
leaq -0x28(%rbp), %rdi
callq 0x30c0
leaq -0x29(%rbp), %rdi
callq 0x3170
movq -0x58(%rbp), %rax
movq 0x3c0(%rax), %rcx
movq %rcx, -0x68(%rbp)
movl 0x3b0(%rax), %ecx
movl %ecx, -0x5c(%rbp)
movq 0x3c0(%rax), %rdi
callq 0xabb0
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
movl %eax, %r8d
xorl %ecx, %ecx
movl $0x1, %r9d
movl %ecx, %edx
callq 0xae20
movq -0x58(%rbp), %rax
cmpq $0x0, 0x428(%rax)
je 0x59ed
movq -0x58(%rbp), %rax
movq 0x428(%rax), %rdi
movq 0x3c0(%rax), %rsi
movq (%rdi), %rax
xorl %edx, %edx
movl $0x1, %ecx
callq *0x30(%rax)
jmp 0x59ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x59e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30c0
leaq -0x29(%rbp), %rdi
callq 0x3170
jmp 0x5a3a
movq -0x58(%rbp), %rax
movq 0x3c0(%rax), %rdi
movl $0x1, %r9d
xorl %ecx, %ecx
movl $0x4, %r8d
movl %r9d, %esi
movl %ecx, %edx
callq 0xae20
movq -0x58(%rbp), %rax
movq 0x3c0(%rax), %rdi
movl $0x3, %esi
xorl %r9d, %r9d
movl $0x4, %r8d
movl %r9d, %edx
movl %r9d, %ecx
callq 0xae20
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rcx
addq $0x3d0, %rcx            # imm = 0x3D0
movq %rcx, -0x28(%rbp)
movq 0x3c8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x71c0
movq -0x20(%rbp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
callq 0x7410
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x3d0, %rdi            # imm = 0x3D0
callq 0x7440
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x5bf2
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x5be5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x5ba8
jmp 0x5bd8
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0xc(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x5e90
jmp 0x5bda
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b8c
jmp 0x5be7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b7f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x5cb3
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x5ca3
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x5c4c
jmp 0x5c96
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0xc(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0x10(%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x5f20
testb $0x1, %al
jne 0x5c8e
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x5db0
testb $0x1, %al
jne 0x5c8e
jmp 0x5c94
movb $0x1, -0x1(%rbp)
jmp 0x5cb7
jmp 0x5c96
jmp 0x5c98
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5c30
jmp 0x5ca5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5c1f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c00
xorb $-0x1, %al
testb $0x1, %al
jne 0x5d04
jmp 0x5d1c
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5cef
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x420(%rax), %rcx
movl 0x10(%rcx), %edx
addl $0x1, %edx
movl %edx, 0x10(%rcx)
movq %rax, %rdi
addq $0x38, %rdi
movq 0x420(%rax), %rsi
callq 0x5c00
testb $0x1, %al
jne 0x5d7d
jmp 0x5d87
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x5e37
movl $0x0, -0x10(%rbp)
cmpl $0x16, -0x10(%rbp)
jge 0x5e2a
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
xorl %esi, %esi
callq 0x5e90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5e08
jmp 0x5e2c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5dfb
movl $0x20, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x14, %esi
movl $0x16, %edx
callq 0xaa20
jmp 0x5e5c
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x370(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
movq -0x18(%rbp), %rdi
callq 0x3270
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x60e4
movl $0x0, -0x10(%rbp)
cmpl $0x16, -0x10(%rbp)
jge 0x60d4
movq -0x60(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5fb0
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6079
movl $0x3, %eax
movl %eax, -0x64(%rbp)
jmp 0x607f
movl -0x14(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rax
movl -0x64(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movq 0x370(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl $0x1, %r8d
callq 0xadc0
movq -0x60(%rbp), %rax
movq 0x370(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
addl $0x1, %edx
movl -0x1c(%rbp), %ecx
movl $0x1, %r8d
callq 0xadc0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x603f
jmp 0x60d6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x602e
movq -0x60(%rbp), %rax
movq 0x370(%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3280
movq -0x70(%rbp), %rdx
leaq 0x6253(%rip), %rsi      # 0xc35e
leaq -0x40(%rbp), %rdi
callq 0x31d0
jmp 0x6116
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xad40
jmp 0x612c
leaq -0x40(%rbp), %rdi
callq 0x30c0
leaq -0x41(%rbp), %rdi
callq 0x3170
movq -0x60(%rbp), %rax
movq 0x370(%rax), %rdi
movl $0x8, %esi
xorl %r9d, %r9d
movl $0x1, %ecx
movl $0x14, %r8d
movl %r9d, %edx
callq 0xae20
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6190
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30c0
leaq -0x41(%rbp), %rdi
callq 0x3170
movq -0x50(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: disjukr[P]Tetris/Tetris.cc
// Function: TetrisStage::RenderGhostPiece(Tetromino&)
void TetrisStage::RenderGhostPiece(Tetromino& piece) {
    Tetromino* ghost = piece.Clone();
    ghost -> color = GREY;
    this -> CastPiece(*ghost);
    this -> RenderPiece(*ghost);
    delete ghost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x18(%rbp), %rsi
callq 0x5cd0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6220
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6213
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: disjukr[P]Tetris/./Randomizer.hh
// Function: Lfsr113::Get()
virtual double Get() {
        unsigned int e = ((a << 6) ^ a) >> 13;
        a = ((a & 4294967294) << 18) ^ e;
        e  = ((b << 2) ^ b) >> 27;
        b = ((b & 4294967288) << 2) ^ e;
        e  = ((c << 13) ^ c) >> 21;
        c = ((c & 4294967280) << 7) ^ e;
        e  = ((d << 3) ^ d) >> 12;
        d = ((d & 4294967168) << 13) ^ e;
        return (a ^ b ^ c ^ d) * 2.3283064365386963e-10;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %edx
movl %edx, %eax
shll $0x6, %eax
xorl %edx, %eax
shrl $0xd, %eax
movl %eax, -0xc(%rbp)
movl 0x8(%rcx), %eax
andl $0x3ffe, %eax           # imm = 0x3FFE
shll $0x12, %eax
movl -0xc(%rbp), %edx
xorl %edx, %eax
movl %eax, 0x8(%rcx)
movl 0xc(%rcx), %edx
movl %edx, %eax
shll $0x2, %eax
xorl %edx, %eax
shrl $0x1b, %eax
movl %eax, -0xc(%rbp)
movl 0xc(%rcx), %eax
andl $0x3ffffff8, %eax       # imm = 0x3FFFFFF8
shll $0x2, %eax
movl -0xc(%rbp), %edx
xorl %edx, %eax
movl %eax, 0xc(%rcx)
movl 0x10(%rcx), %edx
movl %edx, %eax
shll $0xd, %eax
xorl %edx, %eax
shrl $0x15, %eax
movl %eax, -0xc(%rbp)
movl 0x10(%rcx), %eax
andl $0x1fffff0, %eax        # imm = 0x1FFFFF0
shll $0x7, %eax
movl -0xc(%rbp), %edx
xorl %edx, %eax
movl %eax, 0x10(%rcx)
movl 0x14(%rcx), %edx
movl %edx, %eax
shll $0x3, %eax
xorl %edx, %eax
shrl $0xc, %eax
movl %eax, -0xc(%rbp)
movl 0x14(%rcx), %eax
andl $0x7ff80, %eax          # imm = 0x7FF80
shll $0xd, %eax
movl -0xc(%rbp), %edx
xorl %edx, %eax
movl %eax, 0x14(%rcx)
movl 0x8(%rcx), %eax
movl 0xc(%rcx), %edx
xorl %edx, %eax
movl 0x10(%rcx), %edx
xorl %edx, %eax
movl 0x14(%rcx), %ecx
xorl %ecx, %eax
cvtsi2sd %rax, %xmm0
movsd 0x4f49(%rip), %xmm1     # 0xc010
mulsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax)
// File: disjukr[P]Tetris/./Color.hh
// Function: ColorUtil::GetComplementary(Color)
static Color GetComplementary(Color sample) {
        switch (sample) {
        default: return NONE;
        case WHITE: return BLACK;
        case GREY: return GREY;
        case BLACK: return WHITE;
        case BLUE: return YELLOW;
        case CYAN: return RED;
        case GREEN: return MAGENTA;
        case MAGENTA: return GREEN;
        case RED: return CYAN;
        case YELLOW: return BLUE;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x8, %eax
ja 0x70fb
movq -0x10(%rbp), %rax
leaq 0x4f26(%rip), %rcx      # 0xc018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x7153
movl $0x3, -0x4(%rbp)
jmp 0x7153
movl $0x2, -0x4(%rbp)
jmp 0x7153
movl $0x1, -0x4(%rbp)
jmp 0x7153
movl $0x9, -0x4(%rbp)
jmp 0x7153
movl $0x8, -0x4(%rbp)
jmp 0x7153
movl $0x7, -0x4(%rbp)
jmp 0x7153
movl $0x6, -0x4(%rbp)
jmp 0x7153
movl $0x5, -0x4(%rbp)
jmp 0x7153
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: disjukr[P]Tetris/./Tetris.hh
// Function: TetrisStatistics::TetrisStatistics()
TetrisStatistics() {
        score = 0;
        level = 1;
        _single = 0;
        _double = 0;
        _triple = 0;
        _tetris = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x8f80
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x9209
movq -0x28(%rbp), %rax
leaq 0x3402(%rip), %rcx      # 0xc47c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x18, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9670
jmp 0x909e
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9245
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x924f
movl $0x18, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x96b0
jmp 0x90e0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9245
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x924f
movl $0x18, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x96f0
jmp 0x9122
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9245
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x924f
movl $0x18, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x9730
jmp 0x9164
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9245
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x924f
movl $0x18, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x9770
jmp 0x91a6
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9245
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x924f
movl $0x18, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x97b0
jmp 0x91e8
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9245
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x924f
movl $0x18, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x97f0
jmp 0x9224
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9245
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3120
jmp 0x924f
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3270
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x8fc0
movq -0x20(%rbp), %rdi
leaq 0x87a4(%rip), %rax      # 0x11a28
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x6f90
jmp 0x9292
movq -0x20(%rbp), %rax
movl $0x6, 0x40(%rax)
movl $0x5, 0x44(%rax)
movl $0x6, 0x48(%rax)
movl $0x5, 0x4c(%rax)
movb $0x1, 0x38(%rax)
movl $0x0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8ff0
movq -0x10(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x9394
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movslq -0x18(%rbp), %rdx
cmpl 0x40(%rcx,%rdx,4), %eax
jne 0x9387
movb $0x1, -0x1(%rbp)
jmp 0x9398
jmp 0x9389
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x936a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9ac0
testb $0x1, %al
jne 0x999f
movb $0x0, -0x1(%rbp)
jmp 0x99c3
movq -0x20(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x99b7
cmpl $0x1, -0x14(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x99c3
cmpl $0x2, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: disjukr[P]Tetris/./Tetromino.hh
// Function: Tetromino::Render(Screen&, int, int)
virtual void Render(Screen& screen, int x, int y) {
        for (int i = 0; i < size; ++i) {
            for (int j = 0; j < size; ++j) {
                int tx = i * 2 + x;
                int ty = j + y;
                if (this -> CheckBlock(i, j)) {
                    screen.FillCell(this -> color, tx, ty, true);
                    screen.FillCell(this -> color, tx + 1, ty, true);
                }
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x9a8e
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x9a7e
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
shll %eax
addl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x9a36
jmp 0x9a71
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %esi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movl $0x1, %r8d
callq 0xadc0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %esi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl -0x28(%rbp), %ecx
movl $0x1, %r8d
callq 0xadc0
jmp 0x9a73
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9a06
jmp 0x9a80
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x99f5
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: disjukr[P]Tetris/./Tetromino.hh
// Function: TMino::CheckBlock(int, int)
virtual bool CheckBlock(int x, int y) {
        if (!Tetromino::CheckBlock(x, y))
            return false;
        if (y == 0 || x == 3 ||
            ((y == 1 || y == 3) && (x == 0 || x == 2)))
            return false;
        if (vertical) {
            if (x == 1 &&
                ((tail && y == 1) || (!tail && y == 3)))
                return false;
        }
        else {
            if (y == 2 &&
                ((tail && x == 0) || (!tail && x == 2)))
                return false;
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9ac0
testb $0x1, %al
jne 0x9e82
movb $0x0, -0x1(%rbp)
jmp 0x9f16
cmpl $0x0, -0x18(%rbp)
je 0x9ea6
cmpl $0x3, -0x14(%rbp)
je 0x9ea6
cmpl $0x1, -0x18(%rbp)
je 0x9e9a
cmpl $0x3, -0x18(%rbp)
jne 0x9eac
cmpl $0x0, -0x14(%rbp)
je 0x9ea6
cmpl $0x2, -0x14(%rbp)
jne 0x9eac
movb $0x0, -0x1(%rbp)
jmp 0x9f16
movq -0x20(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x9ee4
cmpl $0x1, -0x14(%rbp)
jne 0x9ee2
movq -0x20(%rbp), %rax
testb $0x1, 0x15(%rax)
je 0x9ecc
cmpl $0x1, -0x18(%rbp)
je 0x9edc
movq -0x20(%rbp), %rax
testb $0x1, 0x15(%rax)
jne 0x9ee2
cmpl $0x3, -0x18(%rbp)
jne 0x9ee2
movb $0x0, -0x1(%rbp)
jmp 0x9f16
jmp 0x9f12
cmpl $0x2, -0x18(%rbp)
jne 0x9f10
movq -0x20(%rbp), %rax
testb $0x1, 0x15(%rax)
je 0x9efa
cmpl $0x0, -0x14(%rbp)
je 0x9f0a
movq -0x20(%rbp), %rax
testb $0x1, 0x15(%rax)
jne 0x9f10
cmpl $0x2, -0x14(%rbp)
jne 0x9f10
movb $0x0, -0x1(%rbp)
jmp 0x9f16
jmp 0x9f12
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: disjukr[P]Tetris/./Tetromino.hh
// Function: SMino::CheckBlock(int, int)
virtual bool CheckBlock(int x, int y) {
        if (!Tetromino::CheckBlock(x, y))
            return false;
        if (y == 2 && (x == 1 || x == 2))
            return true;
        if (vertical)
            return (x == 1 && y == 1) || (x == 2 && y == 3);
        else
            return y == 3 && x < 2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9ac0
testb $0x1, %al
jne 0xa0af
movb $0x0, -0x1(%rbp)
jmp 0xa124
cmpl $0x2, -0x18(%rbp)
jne 0xa0c7
cmpl $0x1, -0x14(%rbp)
je 0xa0c1
cmpl $0x2, -0x14(%rbp)
jne 0xa0c7
movb $0x1, -0x1(%rbp)
jmp 0xa124
movq -0x20(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0xa107
cmpl $0x1, -0x14(%rbp)
jne 0xa0e2
movb $0x1, %al
cmpl $0x1, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0xa0fd
xorl %eax, %eax
cmpl $0x2, -0x14(%rbp)
movb %al, -0x22(%rbp)
jne 0xa0f7
cmpl $0x3, -0x18(%rbp)
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa124
xorl %eax, %eax
cmpl $0x3, -0x18(%rbp)
movb %al, -0x23(%rbp)
jne 0xa11c
cmpl $0x2, -0x14(%rbp)
setl %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop