LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: Socket::Socket()
Socket::Socket() {
    my_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (my_socket == INVALID_SOCKET) {
        error_code = ErrorCode::CREATE_ERROR;
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd0d4(%rip), %rax      # 0x108d0
movq %rax, (%rdi)
movl $0x0, 0x34(%rdi)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
movl %eax, 0x8(%rbx)
cmpl $-0x1, %eax
jne 0x3826
movl $0x1, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Bind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ServerSocket::Bind(std::string ip_address, int port) {
    if (IsInvalid()) return -2;
    memset(&my_address, 0, sizeof(my_address));
    my_address.sin_family = AF_INET;
    my_address.sin_port = htons(port);
    my_address.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(my_socket, (struct sockaddr*)&my_address, sizeof(my_address)) == -1) {
        error_code = ErrorCode::BIND_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x0, 0x34(%rdi)
je 0x3858
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
movq $0x0, 0x14(%rdi)
rolw $0x8, %dx
movw $0x2, 0xc(%rdi)
movw %dx, 0xe(%rdi)
movl $0x0, 0x10(%rdi)
movl 0x8(%rdi), %edi
movl $0x10, %edx
callq 0x3060
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x38a4
movl $0x2, 0x34(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Listen(int)
int ServerSocket::Listen(int backlog) {
    if (IsInvalid()) return -2;
    if (listen(my_socket, backlog) == SOCKET_ERROR) {
        error_code = ErrorCode::LISTEN_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x0, 0x34(%rdi)
je 0x38b8
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edi
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x38de
movl $0x3, 0x34(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Recv[abi:cxx11]()
std::string ServerSocket::Recv() {
    char buffer[BUFF_SIZE + 5];
    if (recv(your_socket, buffer, BUFF_SIZE, 0) < 0) {
        throw -1;
    }
    return std::string(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rdi, %rbx
movl 0x1c(%rsi), %edi
leaq -0x2020(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
xorl %ecx, %ecx
callq 0x30e0
testq %rax, %rax
js 0x39c5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x2020(%rbp), %r14
movq %r14, %rdi
callq 0x3130
leaq (%rax,%rbp), %rdx
addq $-0x2020, %rdx          # imm = 0xDFE0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bec
movq %rbx, %rax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
movl $0x4, %edi
callq 0x3150
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0xd5bc(%rip), %rsi      # 0x10f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ClientSocket::Connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ClientSocket::Connect(std::string ip_address, int port) {
#ifdef _WIN32
#else
    struct hostent* host_info;
    struct in_addr addr;
    if ((host_info = gethostbyname(ip_address.c_str())) == 0) {
        error_code = ErrorCode::CONNECT_ERROR;
        return -2;
    }
    memcpy(&addr, host_info->h_addr_list[0], host_info->h_length);
    ip_address = std::string(inet_ntoa(addr));
#endif
    memset(&your_address, 0, sizeof(your_address));
    your_address.sin_family = AF_INET;
    your_address.sin_port = htons(port);
    your_address.sin_addr.s_addr = inet_addr(ip_address.c_str());

    if (connect(my_socket, (struct sockaddr*)&your_address, sizeof(your_address)) == SOCKET_ERROR) {
        error_code = ErrorCode::CONNECT_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x3300
testq %rax, %rax
je 0x3aef
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movslq 0x14(%rax), %rdx
leaq -0x28(%rbp), %r12
movq %r12, %rdi
callq 0x3210
movl (%r12), %edi
callq 0x3140
leaq -0x48(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x3110
movq %r14, %rdi
movq %r12, %rsi
callq 0x3330
movq (%r12), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3aa9
callq 0x3260
leaq 0x20(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movw $0x2, 0x20(%rbx)
rolw $0x8, %r15w
movw %r15w, 0x22(%rbx)
movq (%r14), %rdi
callq 0x32b0
movl %eax, 0x24(%rbx)
movl 0x8(%rbx), %edi
movq %r12, %rsi
movl $0x10, %edx
callq 0x3220
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x3afb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3af4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl $0x5, 0x34(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/cross_library.cpp
// Function: kbhit()
bool kbhit() {
    struct termios oldt, newt;
    int ch;
    int oldf;
    
    tcgetattr(STDIN_FILENO, &oldt);
    newt = oldt;
    newt.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
    
    ch = getchar();
    
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
    fcntl(STDIN_FILENO, F_SETFL, oldf);
    
    if (ch != EOF) {
        ungetc(ch, stdin);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq -0x9c(%rbp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x32d0
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
leaq -0x60(%rbp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movaps %xmm2, 0x20(%rdx)
movups %xmm3, 0x2c(%rdx)
andb $-0xb, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x3340
xorl %edi, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x31a0
movl %eax, %r15d
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x31a0
callq 0x3380
movl %eax, %r14d
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3340
xorl %edi, %edi
movl $0x4, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x31a0
cmpl $-0x1, %r14d
je 0x3d42
movq 0xd281(%rip), %rax      # 0x10fb8
movq (%rax), %rsi
movl %r14d, %edi
callq 0x3070
cmpl $-0x1, %r14d
setne %al
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: Game::DrawPlayerInformation(PlayerInformation const&, int, int)
void Game::DrawPlayerInformation(const PlayerInformation &info, int offset_x, int offset_y) {
    std::cout << Console::white;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(5 + offset_y)) << std::right << std::setw(6) << info.chain_number;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(7 + offset_y)) << std::right << std::setw(6) << info.max_chain_number;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(9 + offset_y)) << std::right << std::setw(6) << info.score;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(12 + offset_y)) << std::right << std::setw(6) << info.obstacle_number_taken;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movq 0xcd72(%rip), %r13      # 0x10fd0
leaq 0xd05f(%rip), %rsi      # 0x112c4
movq %r13, %rdi
callq 0x3e2f
leal 0x12(,%r12,2), %r15d
leal 0x5(%r14), %eax
leaq -0x30(%rbp), %r12
movl %r15d, (%r12)
movl %eax, 0x4(%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x3e76
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl $0xffffff4f, %r13d      # imm = 0xFFFFFF4F
movl 0x18(%rax,%rdx), %esi
andl %r13d, %esi
movl $0x80, %edi
orl %edi, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x3470
leal 0x7(%r14), %eax
movl %r15d, (%r12)
movl %eax, 0x4(%r12)
movq 0xccf3(%rip), %rdi      # 0x10fd0
movq %r12, %rsi
callq 0x3e76
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl %r13d, %esi
movl $0x80, %edi
orl %edi, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x3470
leal 0x9(%r14), %eax
movl %r15d, (%r12)
movl %eax, 0x4(%r12)
movq 0xcca5(%rip), %rdi      # 0x10fd0
movq %r12, %rsi
callq 0x3e76
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl %r13d, %esi
movl $0x80, %edi
orl %edi, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl (%rbx), %esi
movq %rax, %rdi
callq 0x3470
addl $0xc, %r14d
movl %r15d, (%r12)
movl %r14d, 0x4(%r12)
leaq -0x30(%rbp), %rsi
movq 0xcc54(%rip), %rdi      # 0x10fd0
callq 0x3e76
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
andl 0x18(%rax,%rdx), %r13d
movl $0x80, %esi
orl %esi, %r13d
movl %r13d, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3470
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: Game::Draw(std::shared_ptr<Board> const&, std::shared_ptr<BiPuyo> const&, PlayerInformation const&, int, int)
void Game::Draw(const std::shared_ptr<Board> &board, const std::shared_ptr<BiPuyo> &bipuyo, const PlayerInformation &info, int offset_x, int offset_y) {
    Game::DrawFrame(offset_x, offset_y);
    Game::DrawBoard(board, offset_x, offset_y);
    Game::DrawNextBiPuyo(bipuyo, offset_x, offset_y);
    Game::DrawPlayerInformation(info, offset_x, offset_y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %ecx, %edi
movl %r8d, %esi
callq 0x3ee4
movq (%r13), %rdi
leal 0x1(%r14), %esi
leal 0x1(%rbx), %edx
callq 0x6cf6
movq (%r12), %rdi
leal 0xa(%r14), %esi
leal 0x3(%rbx), %edx
callq 0x6e3c
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4240
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: SingleGame::GameInit()
bool SingleGame::GameInit() {
    Console::ScreenClear();
    std::cout << Console::GotoXY(X(0), Y(0));
    
    // prepare game
    my_bipuyo_generator = std::make_shared<BiPuyoGenerator>(); // single game doesn't need sync seed
    my_board = std::make_shared<Board>();
    my_board->SetNextBiPuyo(my_bipuyo_generator->GenerateBipuyo());
    my_next_bipuyo = my_bipuyo_generator->GenerateBipuyo();
    
    std::cout << "Loading..." << std::endl;
    Console::Sleep(500);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0x3dd8
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movq %r12, (%r15)
movq 0xcb84(%rip), %rbx      # 0x10fd0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e76
movq %r12, (%r15)
leaq -0x38(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r15, %rsi
callq 0x9668
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%r14), %rdi
movups %xmm0, 0x10(%r14)
testq %rdi, %rdi
je 0x4496
callq 0x7f4e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x4496
callq 0x7f4e
leaq -0x38(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x21(%rbp), %rdx
movq %r15, %rsi
callq 0x9b26
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x28(%r14), %rdi
movups %xmm0, 0x20(%r14)
testq %rdi, %rdi
je 0x44da
callq 0x7f4e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x44da
callq 0x7f4e
movq 0x20(%r14), %r12
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x6ee8
movq (%r15), %rax
movq %rax, 0x50(%r12)
leaq 0x58(%r12), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0x7fc8
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, 0x60(%r12)
movl $0x0, 0x68(%r12)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4528
callq 0x7f4e
movq 0x10(%r14), %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x6ee8
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x38(%r14), %rdi
movups %xmm0, 0x30(%r14)
testq %rdi, %rdi
je 0x4564
callq 0x7f4e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x4564
callq 0x7f4e
leaq 0x7c65(%rip), %rsi      # 0xc1d0
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x3dc8
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: SingleGame::GameResult()
void SingleGame::GameResult() {
    while (kbhit()) getch();
    Console::ScreenClear();
    std::cout << Console::white << Console::GotoXY(0, 0)
        << "게임 끝" << std::endl
        << "점수: " << my_info.score << std::endl
        << "최대 연쇄: " << my_info.max_chain_number << std::endl
        << "메인으로 돌아가려면 아무키나 누르세요" << std::endl;
    getch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3c8c
testb %al, %al
je 0x479a
callq 0x3d57
jmp 0x478a
callq 0x3dd8
movq 0xc82a(%rip), %rdi      # 0x10fd0
leaq 0xcb17(%rip), %rsi      # 0x112c4
callq 0x3e2f
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x3e76
movq %rax, %r14
leaq 0x7a0c(%rip), %rsi      # 0xc1db
movl $0xa, %edx
movq %rax, %rdi
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x7a41(%rip), %rsi      # 0xc24e
movl $0x8, %edx
movq %rax, %rdi
callq 0x3310
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x7a01(%rip), %rsi      # 0xc25a
movl $0xf, %edx
movq %rax, %rdi
callq 0x3310
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %rbx
leaq 0x7941(%rip), %rsi      # 0xc1e6
movl $0x36, %edx
movq %rax, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
callq 0x3d57
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: VSGame::GameResult()
void VSGame::GameResult() {
    while (kbhit()) getch();
    Console::ScreenClear();
    std::cout << Console::white << Console::GotoXY(0, 0);
    if (my_board->IsGameOver()) {
        std::cout << "1p가 이겼습니다." << std::endl;
    }
    else {
        std::cout << "2p가 이겼습니다." << std::endl;
    }
    std::cout
        << "1p 점수: " << my_info.score << std::endl
        << "1p 최대 연쇄: " << my_info.max_chain_number << std::endl
        << "2p 점수: " << other_info.score << std::endl
        << "2p 최대 연쇄: " << other_info.max_chain_number << std::endl
        << "메인으로 돌아가려면 아무키나 누르세요" << std::endl;
    getch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3c8c
testb %al, %al
je 0x4ece
callq 0x3d57
jmp 0x4ebe
callq 0x3dd8
movq 0xc0f6(%rip), %r14      # 0x10fd0
leaq 0xc3e3(%rip), %rsi      # 0x112c4
movq %r14, %rdi
callq 0x3e2f
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x3e76
movq 0x20(%rbx), %rax
cmpl $0x6, 0x68(%rax)
leaq 0x7312(%rip), %rax      # 0xc21d
leaq 0x7322(%rip), %rsi      # 0xc234
cmoveq %rax, %rsi
movl $0x16, %edx
movq %r14, %rdi
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
leaq 0x72fa(%rip), %rsi      # 0xc24b
movl $0xb, %edx
movq %r14, %rdi
callq 0x3310
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x72ba(%rip), %rsi      # 0xc257
movl $0x12, %edx
movq %rax, %rdi
callq 0x3310
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x7281(%rip), %rsi      # 0xc26a
movl $0xb, %edx
movq %rax, %rdi
callq 0x3310
movl 0x80(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x723e(%rip), %rsi      # 0xc276
movl $0x12, %edx
movq %rax, %rdi
callq 0x3310
movl 0x88(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %rbx
leaq 0x715f(%rip), %rsi      # 0xc1e6
movl $0x36, %edx
movq %rax, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
callq 0x3d57
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: VSGame::Draw()
void VSGame::Draw() {
    /*
        0                   1                   2 
        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
    00  ┌──  ───┐┌───┐  ┌──  ───┐┌───┐ 
     1  │            ││ NEXT │  │            ││ NEXT │ 
     2  │            ││      │  │            ││      │ 
     3  │            ││      │  │            ││      │ 
     4  │            ││      │  │            ││      │ 
     5  │            ││ Chain│  │            ││ Chain│ 
     6  │            ││      │  │            ││      │ 
     7  │            ││MaxChn│  │            ││MaxChn│ 
     8  │            ││      │  │            ││      │ 
     9  │            ││ Score│  │            ││ Score│ 
    10  │            ││      │  │            ││      │ 
     1  │            ││BGM   │  │            ││BGM   │ 
     2  │            ││ObsNum│  │            ││ObsNum│ 
     3  │            ││      │  │            ││      │ 
     4  └──────┘└───┘  └──────┘└───┘ 
    */
    Game::Draw(my_board, my_next_bipuyo, my_info);
    for (int i = 0; i <= 14; i++) {
        std::cout << Console::GotoXY(X(13), Y(i)) << "  ";
    }
    Game::Draw(other_board, other_next_bipuyo, other_info, 14);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
leaq 0x30(%rbx), %rsi
leaq 0x40(%rbx), %rdx
xorl %r13d, %r13d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43c2
movq 0xbed5(%rip), %r14      # 0x10fd0
leaq -0x30(%rbp), %r15
leaq 0x755b(%rip), %r12      # 0xc661
movl $0x1a, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e76
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
incl %r13d
cmpl $0xf, %r13d
jne 0x5106
leaq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rsi
subq $-0x80, %rbx
movq %rbx, %rdx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x43c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: VSRemoteGame::Serialize[abi:cxx11]()
std::string VSRemoteGame::Serialize() {
    std::ostringstream data;
    data
        << "G{"
            << "P{" << my_info.Serialize() << "}"
            << "M{" << my_board->Serialize() << "}"
            << "B{" << my_next_bipuyo->Serialize() << "}"
            << "O{" << obstacle_to_send << "}"
        << "}";
    return data.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1f0(%rbp), %r15
movq %r15, %rdi
callq 0x3360
leaq 0x62dd(%rip), %rsi      # 0xc6d3
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
leaq 0x62cc(%rip), %rsi      # 0xc6d6
leaq -0x1f0(%rbp), %rdi
movl $0x2, %edx
callq 0x3310
leaq 0x40(%r14), %rsi
leaq -0x78(%rbp), %rdi
callq 0x72a8
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x1f0(%rbp), %rdi
callq 0x3310
movq %rax, %r15
leaq 0x6293(%rip), %rsi      # 0xc6d9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x6281(%rip), %rsi      # 0xc6db
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
movq 0x20(%r14), %rsi
leaq -0x58(%rbp), %rdi
callq 0x73ae
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %r15, %rdi
callq 0x3310
movq %rax, %r15
leaq 0x624b(%rip), %rsi      # 0xc6d9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x623c(%rip), %rsi      # 0xc6de
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
movq 0x30(%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x7522
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %r15, %rdi
callq 0x3310
movq %rax, %r15
leaq 0x6203(%rip), %rsi      # 0xc6d9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x61f7(%rip), %rsi      # 0xc6e1
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
movl 0xa0(%r14), %esi
movq %r15, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x61c9(%rip), %rsi      # 0xc6d9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x61b5(%rip), %rsi      # 0xc6d9
movl $0x1, %edx
movq %r14, %rdi
callq 0x3310
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6543
callq 0x3260
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6555
callq 0x3260
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6567
callq 0x3260
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3410
movq 0xaa43(%rip), %rsi      # 0x10fc0
leaq -0x1f0(%rbp), %rdi
callq 0x3180
leaq -0x180(%rbp), %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x65ac
jmp 0x65b6
jmp 0x65b1
movq %rax, %rbx
jmp 0x65d0
movq %rax, %rbx
jmp 0x65f4
movq %rax, %rbx
jmp 0x65e2
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65d0
callq 0x3260
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65e2
callq 0x3260
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65f4
callq 0x3260
movq 0xa9c5(%rip), %rsi      # 0x10fc0
leaq -0x1f0(%rbp), %rdi
callq 0x3180
leaq -0x180(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/game.cpp
// Function: VSRemoteGame::GameResult()
void VSRemoteGame::GameResult() {
    while (kbhit()) getch();
    Console::ScreenClear();
    std::cout << Console::white << Console::GotoXY(0, 0);
    if (my_board->IsGameOver()) {
        std::cout << "졌습니다..." << std::endl;
    }
    else {
        std::cout << "이겼습니다!" << std::endl;
    }
    std::cout
        << "내 점수: " << my_info.score << std::endl
        << "내 최대 연쇄: " << my_info.max_chain_number << std::endl
        << "상대 점수: " << other_info.score << std::endl
        << "상대 최대 연쇄: " << other_info.max_chain_number << std::endl
        << "메인으로 돌아가려면 아무키나 누르세요" << std::endl;
    getch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3c8c
testb %al, %al
je 0x6ae0
callq 0x3d57
jmp 0x6ad0
callq 0x3dd8
movq 0xa4e4(%rip), %r14      # 0x10fd0
leaq 0xa7d1(%rip), %rsi      # 0x112c4
movq %r14, %rdi
callq 0x3e2f
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x3e76
movq 0x20(%rbx), %rax
cmpl $0x6, 0x68(%rax)
jne 0x6b2d
movq 0xa4b1(%rip), %rdi      # 0x10fd0
leaq 0x5b44(%rip), %rsi      # 0xc66a
movl $0xf, %edx
jmp 0x6b40
movq 0xa49c(%rip), %rdi      # 0x10fd0
leaq 0x5b3f(%rip), %rsi      # 0xc67a
movl $0x10, %edx
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
leaq 0x5b18(%rip), %rsi      # 0xc68b
movl $0xc, %edx
movq %r14, %rdi
callq 0x3310
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x5ad9(%rip), %rsi      # 0xc698
movl $0x13, %edx
movq %rax, %rdi
callq 0x3310
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x5aa1(%rip), %rsi      # 0xc6ac
movl $0xf, %edx
movq %rax, %rdi
callq 0x3310
movl 0x80(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x5a62(%rip), %rsi      # 0xc6bc
movl $0x16, %edx
movq %rax, %rdi
callq 0x3310
movl 0x88(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %rbx
leaq 0x553d(%rip), %rsi      # 0xc1e6
movl $0x36, %edx
movq %rax, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
callq 0x3d57
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::Draw(int, int)
void Draw(int offset_x, int offset_y) {
        int sub_x = 0, sub_y = 0;
        if (bipuyo) {
            bipuyo->Draw(bipuyo_x, bipuyo_y, offset_x, offset_y - 1);
            bipuyo->GetDirection(sub_x, sub_y);
        }
        for (int i = 1; i < MAP_HEIGHT; i++) {
            for (int j = 0; j < MAP_WIDTH; j++) {
                if (bipuyo) {
                    if (j == bipuyo_x + sub_x && i == bipuyo_y + sub_y) continue;
                    if (j == bipuyo_x && i == bipuyo_y) continue;
                }
                std::cout << Console::GotoXY(X(offset_x + j), Y(offset_y + i - 1));
                map[i][j].Draw();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x6d63
movl 0x60(%r15), %esi
movl 0x64(%r15), %edx
decl %ebx
movl %r14d, %ecx
movl %ebx, %r8d
callq 0x7db6
movq 0x50(%r15), %rax
movl 0x4(%rax), %eax
cmpl $0x3, %eax
je 0x6d82
movq $0x0, -0x38(%rbp)
cmpl $0x2, %eax
je 0x6d77
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, -0x30(%rbp)
cmpl $0x1, %eax
jne 0x6d93
movq $0x0, -0x30(%rbp)
movl $0x1, %eax
jmp 0x6d8f
decl %ebx
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
jmp 0x6d93
movl $0x1, %eax
movq %rax, -0x30(%rbp)
jmp 0x6d93
movq $0x0, -0x30(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x38(%rbp)
addl %r14d, %r14d
leaq 0x6(%r15), %r12
movl $0x1, %r13d
movq %rbx, -0x50(%rbp)
movl %r14d, -0x3c(%rbp)
leal (%rbx,%r13), %eax
movl %eax, -0x40(%rbp)
xorl %ebx, %ebx
cmpq $0x0, 0x50(%r15)
je 0x6de4
movl 0x60(%r15), %eax
movl 0x64(%r15), %ecx
movq -0x38(%rbp), %rdx
addl %eax, %edx
xorq %rbx, %rdx
movq -0x30(%rbp), %rsi
addl %ecx, %esi
movl %esi, %esi
xorq %r13, %rsi
orq %rdx, %rsi
je 0x6e07
xorq %rbx, %rax
xorq %r13, %rcx
orq %rax, %rcx
je 0x6e07
movl %r14d, -0x48(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x44(%rbp)
movq 0xa1db(%rip), %rdi      # 0x10fd0
leaq -0x48(%rbp), %rsi
callq 0x3e76
leaq (%r12,%rbx), %rdi
callq 0x7e7e
incq %rbx
addl $0x2, %r14d
cmpq $0x6, %rbx
jne 0x6db1
incq %r13
addq $0x6, %r12
cmpq $0xd, %r13
movq -0x50(%rbp), %rbx
movl -0x3c(%rbp), %r14d
jne 0x6da8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./puyo.h
// Function: BiPuyo::Draw(int, int)
void Draw(int offset_x, int offset_y) {
        int x, y;
        GetDirection(x, y);
        std::cout << Console::GotoXY(X(offset_x), Y(offset_y));
        main.Draw();
        std::cout << Console::GotoXY(X(offset_x + x), Y(offset_y + y));
        sub.Draw();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbx
movl 0x4(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
ja 0x6e76
movl $0x2, %r13d
subl %eax, %r13d
movl %ecx, %eax
leaq 0x52ac(%rip), %rcx      # 0xc11c
movl (%rcx,%rax,4), %r14d
jmp 0x6e7f
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %r13d, %r13d
leal (%r15,%r15), %eax
leaq -0x34(%rbp), %r12
movl %eax, (%r12)
movl %edx, 0x4(%r12)
movq 0xa139(%rip), %rdi      # 0x10fd0
movq %r12, %rsi
movl %edx, -0x2c(%rbp)
callq 0x3e76
movq %rbx, %rdi
callq 0x7e7e
addl %r15d, %r13d
addl %r13d, %r13d
addl -0x2c(%rbp), %r14d
movl %r13d, (%r12)
movl %r14d, 0x4(%r12)
leaq -0x34(%rbp), %rsi
movq 0xa108(%rip), %rdi      # 0x10fd0
callq 0x3e76
incq %rbx
movq %rbx, %rdi
callq 0x7e7e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::MoveLeft()
void MoveLeft() {
        int sub_x = 0, sub_y = 0;
        if (bipuyo) {
            bipuyo->GetDirection(sub_x, sub_y);
        }
        if (move_t == 0) {
            move_t = 1;
            if (bipuyo_x != 0 && bipuyo_x + sub_x != 0 && map[bipuyo_y][bipuyo_x - 1].IsBlank() && map[bipuyo_y + sub_y][bipuyo_x + sub_x - 1].IsBlank()) {
                bipuyo_x--;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x50(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x6f9a
movl 0x4(%rcx), %edx
leal -0x1(%rdx), %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
ja 0x6f9c
movl $0x2, %eax
subl %edx, %eax
movl %esi, %ecx
leaq 0x5187(%rip), %rdx      # 0xc11c
movl (%rdx,%rcx,4), %ecx
jmp 0x6f9c
xorl %ecx, %ecx
cmpl $0x0, 0x90(%rdi)
je 0x6fa7
popq %rbp
retq
movl $0x1, 0x90(%rdi)
movslq 0x60(%rdi), %rdx
testq %rdx, %rdx
je 0x6fa5
movl %eax, %esi
negl %esi
cmpl %esi, %edx
je 0x6fa5
movslq 0x64(%rdi), %rsi
leaq (%rsi,%rsi,2), %r8
leaq (%rdi,%r8,2), %r8
cmpb $0x0, -0x1(%rdx,%r8)
jne 0x6fa5
movslq %ecx, %rcx
addq %rcx, %rsi
addl %edx, %eax
decl %eax
cltq
leaq (%rsi,%rsi,2), %rcx
leaq (%rdi,%rcx,2), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x6fa5
decq %rdx
movl %edx, 0x60(%rdi)
jmp 0x6fa5
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::MoveRight()
void MoveRight() {
        int sub_x = 0, sub_y = 0;
        if (bipuyo) {
            bipuyo->GetDirection(sub_x, sub_y);
        }
        if (move_t == 0) {
            move_t = 1;
            if (bipuyo_x != (MAP_WIDTH - 1) && bipuyo_x + sub_x != (MAP_WIDTH - 1) && map[bipuyo_y][bipuyo_x + 1].IsBlank() && map[bipuyo_y + sub_y][bipuyo_x + sub_x + 1].IsBlank()) {
                bipuyo_x++;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x50(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x702c
movl 0x4(%rcx), %edx
leal -0x1(%rdx), %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
ja 0x702e
movl $0x2, %eax
subl %edx, %eax
movl %esi, %ecx
leaq 0x50f5(%rip), %rdx      # 0xc11c
movl (%rdx,%rcx,4), %ecx
jmp 0x702e
xorl %ecx, %ecx
cmpl $0x0, 0x90(%rdi)
jne 0x7083
movl $0x1, 0x90(%rdi)
movslq 0x60(%rdi), %rdx
cmpq $0x5, %rdx
je 0x7083
addl %edx, %eax
cmpl $0x5, %eax
je 0x7083
movslq 0x64(%rdi), %rsi
leaq (%rsi,%rsi,2), %r8
leaq (%rdi,%r8,2), %r8
cmpb $0x0, 0x1(%rdx,%r8)
jne 0x7083
movslq %ecx, %rcx
addq %rcx, %rsi
cltq
leaq (%rsi,%rsi,2), %rcx
leaq (%rdi,%rcx,2), %rcx
cmpb $0x0, 0x1(%rax,%rcx)
jne 0x7083
incq %rdx
movl %edx, 0x60(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::Update()
void Update() {
        switch (state) {
            case State::IDLE: IdleUpdate(); break;
            case State::DROP: DropUpdate(); break;
            case State::CHAINING: ChainingUpdate(); break;
            case State::DROP_OBSTACLE: DropObstacleUpdate(); break;
            case State::NEED_NEXT: break;
            default: { state = State::HALT; } break;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x68(%rdi), %eax
cmpq $0x4, %rax
ja 0x71f5
leaq 0x4efc(%rip), %rcx      # 0xc0d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbp
jmp 0x8108
popq %rbp
jmp 0x86fc
popq %rbp
jmp 0x8260
popq %rbp
jmp 0x82fe
movl $0x5, 0x68(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./player_information.h
// Function: PlayerInformation::Serialize[abi:cxx11]()
std::string Serialize() {
        std::ostringstream data;
        data << score << ' ';
        data << chain_number << ' ';
        data << max_chain_number << ' ';
        data << obstacle_number_taken;
        return data.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x198(%rbp), %r15
movq %r15, %rdi
callq 0x3360
movl (%r14), %esi
movq %r15, %rdi
callq 0x3470
leaq -0x19(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
movl 0x4(%r14), %esi
leaq -0x198(%rbp), %rdi
callq 0x3470
leaq -0x19(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
movl 0x8(%r14), %esi
leaq -0x198(%rbp), %rdi
callq 0x3470
leaq -0x19(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
movl 0xc(%r14), %esi
leaq -0x198(%rbp), %rdi
callq 0x3470
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x3410
movq 0x9c66(%rip), %rsi      # 0x10fc0
leaq -0x198(%rbp), %rdi
callq 0x3180
leaq -0x128(%rbp), %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x9c33(%rip), %rsi      # 0x10fc0
leaq -0x198(%rbp), %rdi
callq 0x3180
leaq -0x128(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::Serialize[abi:cxx11]()
std::string Serialize() {
        std::ostringstream data;
        for (int i = 0; i < MAP_HEIGHT; i++) {
            for (int j = 0; j < MAP_WIDTH; j++) {
                data << map[i][j].Serialize();
            }
        }
        data << static_cast<int>(state);
        if (bipuyo) {
            data << bipuyo->Serialize();
            data << bipuyo_x << " ";
            data << bipuyo_y;
        }
        return data.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq -0x1d0(%rbp), %r15
movq %r15, %rdi
callq 0x3360
xorl %r13d, %r13d
leaq -0x58(%rbp), %r12
movq %r14, -0x30(%rbp)
movq $-0x6, %rbx
movb 0x6(%r14,%rbx), %al
addb $0x61, %al
movb %al, -0x58(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3310
incq %rbx
jne 0x73ea
incq %r13
addq $0x6, %r14
cmpq $0xd, %r13
jne 0x73e3
movq -0x30(%rbp), %r14
movl 0x68(%r14), %esi
leaq -0x1d0(%rbp), %rdi
callq 0x3470
movq -0x38(%rbp), %rbx
movq 0x50(%r14), %rsi
testq %rsi, %rsi
je 0x749a
leaq -0x58(%rbp), %rdi
callq 0x7522
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x1d0(%rbp), %rdi
callq 0x3310
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7466
callq 0x3260
movl 0x60(%r14), %esi
leaq -0x1d0(%rbp), %rdi
callq 0x3470
leaq 0x51e5(%rip), %rsi      # 0xc662
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
movl 0x64(%r14), %esi
leaq -0x1d0(%rbp), %rdi
callq 0x3470
leaq -0x1c8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3410
movq 0x9b10(%rip), %rsi      # 0x10fc0
leaq -0x1d0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x74fb
callq 0x3260
jmp 0x74fb
jmp 0x74f8
jmp 0x74f8
movq %rax, %rbx
movq 0x9abe(%rip), %rsi      # 0x10fc0
leaq -0x1d0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./puyo.h
// Function: BiPuyo::Serialize[abi:cxx11]()
std::string Serialize() {
        std::ostringstream data;
        data << main.Serialize();
        data << sub.Serialize();
        data << static_cast<int>(direction);
        return data.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x198(%rbp), %r15
movq %r15, %rdi
callq 0x3360
movb (%r14), %al
addb $0x61, %al
leaq -0x19(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x3310
movb 0x1(%r14), %al
addb $0x61, %al
leaq -0x19(%rbp), %rsi
movb %al, (%rsi)
leaq -0x198(%rbp), %rdi
movl $0x1, %edx
callq 0x3310
movl 0x4(%r14), %esi
leaq -0x198(%rbp), %rdi
callq 0x3470
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x3410
movq 0x9a1e(%rip), %rsi      # 0x10fc0
leaq -0x198(%rbp), %rdi
callq 0x3180
leaq -0x128(%rbp), %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x99eb(%rip), %rsi      # 0x10fc0
leaq -0x198(%rbp), %rdi
callq 0x3180
leaq -0x128(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./puyo.h
// Function: BiPuyo::Draw(int, int, int, int)
void Draw(int x, int y, int offset_x, int offset_y) {
        int sub_x, sub_y;
        GetDirection(sub_x, sub_y);
        if (y > 0) {
            std::cout << Console::GotoXY(X(x + offset_x), Y(y + offset_y));
            main.Draw();
        }
        if (y + sub_y > 0) {
            std::cout << Console::GotoXY(X(x + offset_x + sub_x), Y(y + offset_y + sub_y));
            sub.Draw();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
movl 0x4(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
ja 0x7df5
movl $0x2, %r13d
subl %eax, %r13d
movl %ecx, %eax
leaq 0x432c(%rip), %rcx      # 0xc11c
movl (%rcx,%rax,4), %ecx
jmp 0x7dfd
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r13d, %r13d
testl %r12d, %r12d
jle 0x7e37
leal (%r15,%rsi), %eax
addl %eax, %eax
movl %ecx, -0x2c(%rbp)
leal (%r14,%r12), %ecx
movq %rsi, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movq 0x91ad(%rip), %rdi      # 0x10fd0
callq 0x3e76
movq %rbx, %rdi
callq 0x7e7e
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rsi
movl %ecx, %eax
addl %r12d, %eax
jle 0x7e6f
addl %esi, %r15d
addl %r13d, %r15d
addl %r15d, %r15d
addl %r12d, %r14d
addl %ecx, %r14d
leaq -0x40(%rbp), %rsi
movl %r15d, (%rsi)
movl %r14d, 0x4(%rsi)
movq 0x9171(%rip), %rdi      # 0x10fd0
callq 0x3e76
incq %rbx
movq %rbx, %rdi
callq 0x7e7e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./puyo.h
// Function: Puyo::Draw()
void Draw() {
        switch (puyo) {
            case PuyoKind::BLANK:
                std::cout << Console::black << "  ";
                break;
            case PuyoKind::RED:
                std::cout << Console::red << "●";
                break;
            case PuyoKind::YELLOW:
                std::cout << Console::yellow << "●";
                break;
            case PuyoKind::GREEN:
                std::cout << Console::green << "●";
                break;
            case PuyoKind::BLUE:
                std::cout << Console::blue << "●";
                break;
            case PuyoKind::OBSTACLE:
                std::cout << Console::white << "○";
                break;
            case PuyoKind::EXPLOSION:
                std::cout << Console::gray << "※";
                break; 
            default: break;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl (%rdi), %eax
cmpq $0x6, %rax
ja 0x7eec
leaq 0x4296(%rip), %rcx      # 0xc128
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x912e(%rip), %rdi      # 0x10fd0
leaq 0x93df(%rip), %rsi      # 0x11288
callq 0x3e2f
leaq 0x47ac(%rip), %rsi      # 0xc661
movl $0x2, %edx
jmp 0x7f0d
movq 0x910d(%rip), %rdi      # 0x10fd0
leaq 0x93e2(%rip), %rsi      # 0x112ac
jmp 0x7efc
movq 0x90fd(%rip), %rdi      # 0x10fd0
leaq 0x93e6(%rip), %rsi      # 0x112c0
jmp 0x7efc
movq 0x90ed(%rip), %rdi      # 0x10fd0
leaq 0x93c6(%rip), %rsi      # 0x112b0
jmp 0x7efc
popq %rbp
retq
movq 0x90db(%rip), %rdi      # 0x10fd0
leaq 0x93bc(%rip), %rsi      # 0x112b8
callq 0x3e2f
leaq 0x47dc(%rip), %rsi      # 0xc6e4
movl $0x3, %edx
movq %rax, %rdi
popq %rbp
jmp 0x3310
movq 0x90b3(%rip), %rdi      # 0x10fd0
leaq 0x93a0(%rip), %rsi      # 0x112c4
callq 0x3e2f
leaq 0x47b8(%rip), %rsi      # 0xc6e8
jmp 0x7f08
movq 0x9097(%rip), %rdi      # 0x10fd0
leaq 0x9364(%rip), %rsi      # 0x112a4
callq 0x3e2f
leaq 0x47a0(%rip), %rsi      # 0xc6ec
jmp 0x7f08
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::IdleUpdate()
void IdleUpdate() {
        int sub_x = 0, sub_y = 0;
        if (bipuyo) {
            bipuyo->GetDirection(sub_x, sub_y);
        }
        if (gravity_t++ > GRAVITY_FRAME) {
            gravity_t = 0;
            if (bipuyo_y < (MAP_HEIGHT - 1) && map[bipuyo_y + 1][bipuyo_x].IsBlank() && bipuyo_y + sub_y < (MAP_HEIGHT - 1) && map[bipuyo_y + sub_y + 1][bipuyo_x + sub_x].IsBlank()) {
                bipuyo_y++;
            }
            else {
                map[bipuyo_y][bipuyo_x] = Puyo(bipuyo->GetMain());
                if (bipuyo_y + sub_y >= 0)
                    map[bipuyo_y + sub_y][bipuyo_x + sub_x] = Puyo(bipuyo->GetSub());
                bipuyo.reset();
                state = State::DROP;
            }
        }
        if (rotate_t > ROTATE_FRAME) {
            rotate_t = 0;
        }
        else if (rotate_t > 0) {
            rotate_t++;
        }
        if (move_t > MOVE_FRAME) {
            move_t = 0;
        }
        else if (move_t > 0) {
            move_t++;
        }
        if (down_t > DOWN_FRAME) {
            down_t = 0;
        }
        else if (down_t > 0) {
            down_t++;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x8141
movl 0x4(%rax), %esi
leal -0x1(%rsi), %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x2, %edi
ja 0x8143
movl %edi, %ecx
leaq 0x3fe7(%rip), %rdx      # 0xc11c
movl (%rdx,%rcx,4), %edx
movl $0x2, %ecx
subl %esi, %ecx
jmp 0x8143
xorl %edx, %edx
movl 0x80(%rbx), %esi
leal 0x1(%rsi), %edi
movl %edi, 0x80(%rbx)
cmpl 0x7c(%rbx), %esi
jle 0x81fe
movl $0x0, 0x80(%rbx)
movslq 0x64(%rbx), %rdi
cmpq $0xc, %rdi
jge 0x81b4
leaq 0x1(%rdi), %r9
movl 0x60(%rbx), %esi
movslq %esi, %r8
leaq (%r9,%r9,2), %r10
leaq (%rbx,%r10,2), %r10
cmpb $0x0, (%r8,%r10)
jne 0x81ba
leal (%rdi,%rdx), %r10d
cmpl $0xb, %r10d
jg 0x81ba
incl %r10d
movslq %r10d, %r10
leal (%rsi,%rcx), %r11d
movslq %r11d, %r11
leaq (%r10,%r10,2), %r10
leaq (%rbx,%r10,2), %r10
cmpb $0x0, (%r11,%r10)
jne 0x81ba
movl %r9d, 0x64(%rbx)
jmp 0x81fe
movl 0x60(%rbx), %esi
movslq %esi, %r8
movb (%rax), %r9b
leaq (%rdi,%rdi,2), %r10
leaq (%rbx,%r10,2), %r10
movb %r9b, (%r8,%r10)
addl %edi, %edx
js 0x81e2
movb 0x1(%rax), %al
movl %edx, %edx
addl %ecx, %esi
movslq %esi, %rcx
leaq (%rdx,%rdx,2), %rdx
leaq (%rbx,%rdx,2), %rdx
movb %al, (%rcx,%rdx)
xorps %xmm0, %xmm0
movq 0x58(%rbx), %rdi
movups %xmm0, 0x50(%rbx)
testq %rdi, %rdi
je 0x81f7
callq 0x7f4e
movl $0x1, 0x68(%rbx)
movl 0x88(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x84(%rbx), %eax
jg 0x8216
testl %eax, %eax
jle 0x821c
incl %eax
movl %eax, %ecx
movl %ecx, 0x88(%rbx)
movl 0x90(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x8c(%rbx), %eax
jg 0x8234
testl %eax, %eax
jle 0x823a
incl %eax
movl %eax, %ecx
movl %ecx, 0x90(%rbx)
movl 0x98(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x94(%rbx), %eax
jg 0x8252
testl %eax, %eax
jle 0x8258
incl %eax
movl %eax, %ecx
movl %ecx, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::DropUpdate()
void DropUpdate() {
        if (drop_predelay_t++ < DROP_PREDELAY)
            return;
        if (drop_t++ < DROP_FRAME)
            return;
        drop_t = 0;
        bool isChanged = ShiftDown();
        if (!isChanged) {
            state = State::CHAINING;
            drop_predelay_t = 0;
        }
    }

// Assembly:
movl 0xa0(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xa0(%rdi)
cmpl 0x9c(%rdi), %eax
jl 0x82fc
movl 0xa8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xa8(%rdi)
cmpl 0xa4(%rdi), %eax
jl 0x82fc
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0xa8(%rdi)
leaq 0x48(%rdi), %rax
movl $0xc, %ecx
xorl %edx, %edx
leaq -0x1(%rcx), %rsi
movq $-0x6, %r8
cmpb $0x0, 0x6(%rax,%r8)
jne 0x82d3
movb (%rax,%r8), %r9b
testb %r9b, %r9b
je 0x82d3
movb %r9b, 0x6(%rax,%r8)
movb $0x0, (%rax,%r8)
movb $0x1, %dl
incq %r8
jne 0x82b6
addq $-0x6, %rax
cmpq $0x1, %rcx
movq %rsi, %rcx
ja 0x82ab
testb $0x1, %dl
popq %rbp
jne 0x82fc
movl $0x2, 0x68(%rdi)
movl $0x0, 0xa0(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Leeingnyo[P]newPuyoC/./WELLRNG512Gen.h
// Function: WELLRNG512Generator::WELLRNG512Generator()
WELLRNG512Generator() {
            std::random_device rd;
            std::mt19937 rand(rd());
            for (int i = 0; i < 16; i++)
                state[i] = rand();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
movq %rdi, %rbx
movl $0x0, 0x80(%rdi)
leaq -0x2728(%rbp), %r14
movq %r14, %rdi
callq 0x9964
movq %r14, %rdi
callq 0x3370
movl %eax, %eax
movq %rax, -0x13a0(%rbp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, -0x13a0(%rbp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x98d8
leaq -0x13a0(%rbp), %r14
movq $0x270, 0x1380(%r14) # imm = 0x270
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x99d4
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq $0x10, %r15
jne 0x9912
leaq -0x2728(%rbp), %rdi
callq 0x3250
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x995c
jmp 0x9945
movq %rax, %rbx
leaq -0x2728(%rbp), %rdi
callq 0x3250
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x7fba