LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c94
testb %al, %al
je 0x6b0e
callq 0x3d5f
jmp 0x6afe
callq 0x3de0
movq 0xa4b6(%rip), %r14      # 0x10fd0
leaq 0xa7a3(%rip), %rsi      # 0x112c4
movq %r14, %rdi
callq 0x3e37
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x3e7e
movq 0x20(%rbx), %rax
cmpl $0x6, 0x68(%rax)
jne 0x6b5b
movq 0xa483(%rip), %rdi      # 0x10fd0
leaq 0x5b36(%rip), %rsi      # 0xc68a
movl $0xf, %edx
jmp 0x6b6e
movq 0xa46e(%rip), %rdi      # 0x10fd0
leaq 0x5b31(%rip), %rsi      # 0xc69a
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 0x5b0a(%rip), %rsi      # 0xc6ab
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 0x5acb(%rip), %rsi      # 0xc6b8
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 0x5a93(%rip), %rsi      # 0xc6cc
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 0x5a54(%rip), %rsi      # 0xc6dc
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 0x552f(%rip), %rsi      # 0xc206
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 0x3d5f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, -0x38(%rbp)
testq %rdi, %rdi
je 0x6d94
movl 0x60(%r15), %esi
movl 0x64(%r15), %edx
leal -0x1(%rbx), %r8d
movl %r14d, %ecx
callq 0x7e14
movq 0x50(%r15), %rax
movl 0x4(%rax), %eax
leal -0x1(%rax), %ecx
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
ja 0x6d9b
movl $0x2, %edx
subl %eax, %edx
movq %rdx, -0x38(%rbp)
movl %ecx, %eax
leaq 0x53b0(%rip), %rcx      # 0xc13c
movl (%rcx,%rax,4), %eax
movl %eax, -0x2c(%rbp)
jmp 0x6d9b
movl $0x0, -0x2c(%rbp)
decl %ebx
addl %r14d, %r14d
leaq 0x6(%r15), %rax
movq %rax, -0x40(%rbp)
movl $0x1, %r12d
movq %rbx, -0x50(%rbp)
movl %r14d, -0x30(%rbp)
leal (%rbx,%r12), %r13d
movl %r14d, %ebx
xorl %r14d, %r14d
cmpq $0x0, 0x50(%r15)
je 0x6df0
movl 0x60(%r15), %eax
movq -0x38(%rbp), %rcx
addl %eax, %ecx
cmpq %rcx, %r14
jne 0x6de2
movl 0x64(%r15), %ecx
addl -0x2c(%rbp), %ecx
cmpq %rcx, %r12
je 0x6e14
cmpq %rax, %r14
jne 0x6df0
movl 0x64(%r15), %eax
cmpq %rax, %r12
je 0x6e14
movl %ebx, -0x48(%rbp)
movl %r13d, -0x44(%rbp)
movq 0xa1d2(%rip), %rdi      # 0x10fd0
leaq -0x48(%rbp), %rsi
callq 0x3e7e
movq -0x40(%rbp), %rax
leaq (%rax,%r14), %rdi
callq 0x7edc
incq %r14
addl $0x2, %ebx
cmpq $0x6, %r14
jne 0x6dc0
incq %r12
addq $0x6, -0x40(%rbp)
cmpq $0xd, %r12
movq -0x50(%rbp), %rbx
movl -0x30(%rbp), %r14d
jne 0x6db6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e80
movl $0x2, %r13d
subl %eax, %r13d
movl %ecx, %eax
leaq 0x52c2(%rip), %rcx      # 0xc13c
movl (%rcx,%rax,4), %r14d
jmp 0x6e89
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %r13d, %r13d
leal (%r15,%r15), %eax
leaq -0x34(%rbp), %r12
movl %eax, (%r12)
movl %edx, 0x4(%r12)
movq 0xa12f(%rip), %rdi      # 0x10fd0
movq %r12, %rsi
movl %edx, -0x2c(%rbp)
callq 0x3e7e
movq %rbx, %rdi
callq 0x7edc
addl %r15d, %r13d
addl %r13d, %r13d
addl -0x2c(%rbp), %r14d
movl %r13d, (%r12)
movl %r14d, 0x4(%r12)
leaq -0x34(%rbp), %rsi
movq 0xa0fe(%rip), %rdi      # 0x10fd0
callq 0x3e7e
incq %rbx
movq %rbx, %rdi
callq 0x7edc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6fac
movl 0x4(%rcx), %edx
leal -0x1(%rdx), %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
ja 0x6fae
movl $0x2, %eax
subl %edx, %eax
movl %esi, %ecx
leaq 0x5195(%rip), %rdx      # 0xc13c
movl (%rdx,%rcx,4), %ecx
jmp 0x6fae
xorl %ecx, %ecx
cmpl $0x0, 0x90(%rdi)
je 0x6fb9
popq %rbp
retq
movl $0x1, 0x90(%rdi)
movslq 0x60(%rdi), %rdx
testq %rdx, %rdx
je 0x6fb7
movl %eax, %esi
negl %esi
cmpl %esi, %edx
je 0x6fb7
movslq 0x64(%rdi), %rsi
leaq (%rsi,%rsi,2), %r8
leaq (%rdi,%r8,2), %r8
cmpb $0x0, -0x1(%rdx,%r8)
jne 0x6fb7
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 0x6fb7
decq %rdx
movl %edx, 0x60(%rdi)
jmp 0x6fb7
// File: /workspace/github_cpp_makefile_star2_O1/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 0x703e
movl 0x4(%rcx), %edx
leal -0x1(%rdx), %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
ja 0x7040
movl $0x2, %eax
subl %edx, %eax
movl %esi, %ecx
leaq 0x5103(%rip), %rdx      # 0xc13c
movl (%rdx,%rcx,4), %ecx
jmp 0x7040
xorl %ecx, %ecx
cmpl $0x0, 0x90(%rdi)
jne 0x7095
movl $0x1, 0x90(%rdi)
movslq 0x60(%rdi), %rdx
cmpq $0x5, %rdx
je 0x7095
addl %edx, %eax
cmpl $0x5, %eax
je 0x7095
movslq 0x64(%rdi), %rsi
leaq (%rsi,%rsi,2), %r8
leaq (%rdi,%r8,2), %r8
cmpb $0x0, 0x1(%rdx,%r8)
jne 0x7095
movslq %ecx, %rcx
addq %rcx, %rsi
cltq
leaq (%rsi,%rsi,2), %rcx
leaq (%rdi,%rcx,2), %rcx
cmpb $0x0, 0x1(%rax,%rcx)
jne 0x7095
incq %rdx
movl %edx, 0x60(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x725d
leaq 0x4eb4(%rip), %rcx      # 0xc0f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbp
jmp 0x817a
popq %rbp
jmp 0x875c
popq %rbp
jmp 0x82d0
popq %rbp
jmp 0x836e
movl $0x5, 0x68(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9bfe(%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 0x9bcb(%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_O1/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 0x7452
incq %r13
addq $0x6, %r14
cmpq $0xd, %r13
jne 0x744b
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 0x7502
leaq -0x58(%rbp), %rdi
callq 0x758a
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 0x74ce
callq 0x3260
movl 0x60(%r14), %esi
leaq -0x1d0(%rbp), %rdi
callq 0x3470
leaq 0x519d(%rip), %rsi      # 0xc682
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 0x9aa8(%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 0x7563
callq 0x3260
jmp 0x7563
jmp 0x7560
jmp 0x7560
movq %rax, %rbx
movq 0x9a56(%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_O1/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 0x99b6(%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 0x9983(%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_O1/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 0x7e53
movl $0x2, %r13d
subl %eax, %r13d
movl %ecx, %eax
leaq 0x42ee(%rip), %rcx      # 0xc13c
movl (%rcx,%rax,4), %ecx
jmp 0x7e5b
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r13d, %r13d
testl %r12d, %r12d
jle 0x7e95
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 0x914f(%rip), %rdi      # 0x10fd0
callq 0x3e7e
movq %rbx, %rdi
callq 0x7edc
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rsi
movl %ecx, %eax
addl %r12d, %eax
jle 0x7ecd
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 0x9113(%rip), %rdi      # 0x10fd0
callq 0x3e7e
incq %rbx
movq %rbx, %rdi
callq 0x7edc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7f4a
leaq 0x4258(%rip), %rcx      # 0xc148
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x90d0(%rip), %rdi      # 0x10fd0
leaq 0x9381(%rip), %rsi      # 0x11288
callq 0x3e37
leaq 0x476e(%rip), %rsi      # 0xc681
movl $0x2, %edx
jmp 0x7f6b
movq 0x90af(%rip), %rdi      # 0x10fd0
leaq 0x9384(%rip), %rsi      # 0x112ac
jmp 0x7f5a
movq 0x909f(%rip), %rdi      # 0x10fd0
leaq 0x9388(%rip), %rsi      # 0x112c0
jmp 0x7f5a
movq 0x908f(%rip), %rdi      # 0x10fd0
leaq 0x9368(%rip), %rsi      # 0x112b0
jmp 0x7f5a
popq %rbp
retq
movq 0x907d(%rip), %rdi      # 0x10fd0
leaq 0x935e(%rip), %rsi      # 0x112b8
callq 0x3e37
leaq 0x479e(%rip), %rsi      # 0xc704
movl $0x3, %edx
movq %rax, %rdi
popq %rbp
jmp 0x3310
movq 0x9055(%rip), %rdi      # 0x10fd0
leaq 0x9342(%rip), %rsi      # 0x112c4
callq 0x3e37
leaq 0x477a(%rip), %rsi      # 0xc708
jmp 0x7f66
movq 0x9039(%rip), %rdi      # 0x10fd0
leaq 0x9306(%rip), %rsi      # 0x112a4
callq 0x3e37
leaq 0x4762(%rip), %rsi      # 0xc70c
jmp 0x7f66
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/./WELLRNG512Gen.h
// Function: WELLRNG512Generator::Generate()
unsigned long Generate() {
            // http://www.gamedevforever.com/114
            unsigned long a, b, c, d;
            a = state[index];
            c = state[(index+13)&15];
            b = a^c^(a<<16)^(c<<15);
            c = state[(index+9)&15];
            c ^= (c>>11);
            a = state[index] = b^c;
            d = a^((a<<5)&0xDA442D20UL);
            index = (index + 15)&15;
            a = state[index];
            state[index] = a^b^d^(a<<2)^(b<<18)^(c<<28);
            return state[index];
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x80(%rdi), %rdx
movq (%rdi,%rdx,8), %rax
leal 0xd(%rdx), %ecx
andl $0xf, %ecx
movq (%rdi,%rcx,8), %rcx
movq %rax, %rsi
shlq $0x10, %rsi
xorq %rax, %rsi
xorq %rcx, %rsi
shlq $0xf, %rcx
xorq %rsi, %rcx
leal 0x9(%rdx), %eax
andl $0xf, %eax
movq (%rdi,%rax,8), %rsi
movq %rsi, %rax
shrq $0xb, %rax
xorq %rsi, %rax
movq %rcx, %rsi
xorq %rax, %rsi
movq %rsi, (%rdi,%rdx,8)
shll $0x5, %esi
andl $0xda442d20, %esi       # imm = 0xDA442D20
decl %edx
andl $0xf, %edx
movl %edx, 0x80(%rdi)
movq (%rdi,%rdx,8), %r8
leaq (,%r8,4), %r9
shlq $0x12, %rcx
movq %rax, %r10
shlq $0x1c, %r10
xorq %r9, %r10
xorq %rcx, %r10
xorq %rsi, %r10
xorq %r8, %rax
xorq %r10, %rax
movq %rax, (%rdi,%rdx,8)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81b3
movl 0x4(%rax), %esi
leal -0x1(%rsi), %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x2, %edi
ja 0x81b5
movl %edi, %ecx
leaq 0x3f95(%rip), %rdx      # 0xc13c
movl (%rdx,%rcx,4), %edx
movl $0x2, %ecx
subl %esi, %ecx
jmp 0x81b5
xorl %edx, %edx
movl 0x80(%rbx), %esi
leal 0x1(%rsi), %edi
movl %edi, 0x80(%rbx)
cmpl 0x7c(%rbx), %esi
jle 0x826a
movl $0x0, 0x80(%rbx)
movslq 0x64(%rbx), %rsi
cmpq $0xb, %rsi
jg 0x8221
leaq 0x1(%rsi), %rdi
movslq 0x60(%rbx), %r8
leaq (%rdi,%rdi,2), %r9
leaq (%rbx,%r9,2), %r9
cmpb $0x0, (%r8,%r9)
jne 0x8221
leal (%rsi,%rdx), %r9d
cmpl $0xb, %r9d
jg 0x8221
incl %r9d
movslq %r9d, %r9
movslq %ecx, %r10
addq %r10, %r8
leaq (%r9,%r9,2), %r9
leaq (%rbx,%r9,2), %r9
cmpb $0x0, (%r9,%r8)
je 0x82cb
movb (%rax), %r8b
movslq 0x60(%rbx), %rdi
leaq (%rsi,%rsi,2), %r9
leaq (%rbx,%r9,2), %r9
movb %r8b, (%rdi,%r9)
addl %esi, %edx
js 0x824e
movb 0x1(%rax), %al
movl %edx, %edx
movslq %ecx, %rcx
addq %rcx, %rdi
leaq (%rdx,%rdx,2), %rcx
leaq (%rbx,%rcx,2), %rcx
movb %al, (%rcx,%rdi)
xorps %xmm0, %xmm0
movq 0x58(%rbx), %rdi
movups %xmm0, 0x50(%rbx)
testq %rdi, %rdi
je 0x8263
callq 0x7fac
movl $0x1, 0x68(%rbx)
movl 0x88(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x84(%rbx), %eax
jg 0x8282
testl %eax, %eax
jle 0x8288
incl %eax
movl %eax, %ecx
movl %ecx, 0x88(%rbx)
movl 0x90(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x8c(%rbx), %eax
jg 0x82a0
testl %eax, %eax
jle 0x82a6
incl %eax
movl %eax, %ecx
movl %ecx, 0x90(%rbx)
movl 0x98(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x94(%rbx), %eax
jg 0x82be
testl %eax, %eax
jle 0x82c4
incl %eax
movl %eax, %ecx
movl %ecx, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %edi, 0x64(%rbx)
jmp 0x826a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x836c
movl 0xa8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xa8(%rdi)
cmpl 0xa4(%rdi), %eax
jl 0x836c
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 0x8343
movb (%rax,%r8), %r9b
testb %r9b, %r9b
je 0x8343
movb %r9b, 0x6(%rax,%r8)
movb $0x0, (%rax,%r8)
movb $0x1, %dl
incq %r8
jne 0x8326
addq $-0x6, %rax
cmpq $0x1, %rcx
movq %rsi, %rcx
ja 0x831b
testb $0x1, %dl
popq %rbp
jne 0x836c
movl $0x2, 0x68(%rdi)
movl $0x0, 0xa0(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x99f4
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 0x9968
leaq -0x13a0(%rbp), %r14
movq $0x270, 0x1380(%r14) # imm = 0x270
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x9a64
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq $0x10, %r15
jne 0x99a2
leaq -0x2728(%rbp), %rdi
callq 0x3250
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x99ec
jmp 0x99d5
movq %rax, %rbx
leaq -0x2728(%rbp), %rdi
callq 0x3250
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x8018
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_bsm_benchmark.cpp
// Function: double call_bsm_model<double>(double, double, double, double, double)
inline T call_bsm_model(T s, T k, T t, T r, T v)
{
   using namespace std;
   using namespace exprtk::details::numeric;

   const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
   const T d2 = d1 - v * sqrt(t);
   return s * ncdf(d1) - k * exp(-r * t) * ncdf(d2);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm4, 0x10(%rsp)
movaps %xmm3, 0x30(%rsp)
movsd %xmm2, (%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
divsd %xmm1, %xmm0
callq 0x1160f0
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x1ac2c8(%rip), %xmm1   # 0x2c7028
addsd 0x30(%rsp), %xmm1
movsd (%rsp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
xorps %xmm2, %xmm2
sqrtsd %xmm3, %xmm2
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
movapd %xmm2, %xmm0
jae 0x11adae
movsd (%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x116230
xorpd %xmm4, %xmm4
movsd 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm4, %xmm0
jae 0x11addd
movsd (%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x116230
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
divsd 0x1ac233(%rip), %xmm1   # 0x2c7030
movapd %xmm1, %xmm0
callq 0x1163f0
mulsd 0x1ac21a(%rip), %xmm0   # 0x2c7028
movsd %xmm0, 0x10(%rsp)
movapd 0x30(%rsp), %xmm0
xorpd 0x1ac2ee(%rip), %xmm0   # 0x2c7110
mulsd (%rsp), %xmm0
callq 0x1160b0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
divsd 0x1ac1f1(%rip), %xmm0   # 0x2c7030
callq 0x1163f0
mulsd 0x1ac1dc(%rip), %xmm0   # 0x2c7028
movsd (%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_bsm_benchmark.cpp
// Function: double put_bsm_model<double>(double, double, double, double, double)
inline T put_bsm_model(T s, T k, T t, T r, T v)
{
   using namespace std;
   using namespace exprtk::details::numeric;

   const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
   const T d2 = d1 - v * sqrt(t);
   return k * exp(-r * t) * ncdf(-d2) - s * ncdf(-d1);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm4, 0x8(%rsp)
movaps %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
divsd %xmm1, %xmm0
callq 0x1160f0
movsd 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x1ac176(%rip), %xmm1   # 0x2c7028
addsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm3, %xmm3
sqrtsd %xmm2, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm2
movapd %xmm3, %xmm0
jae 0x11af00
movapd %xmm2, %xmm0
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x30(%rsp)
callq 0x116230
xorpd %xmm4, %xmm4
movsd 0x30(%rsp), %xmm3
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
divsd %xmm0, %xmm1
ucomisd %xmm4, %xmm2
movsd %xmm1, 0x10(%rsp)
jae 0x11af2f
movapd %xmm2, %xmm0
callq 0x116230
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x8(%rsp), %xmm0
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd 0x20(%rsp), %xmm0
xorpd 0x1ac1bf(%rip), %xmm0   # 0x2c7110
mulsd %xmm2, %xmm0
callq 0x1160b0
mulsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
divsd 0x1ac0c4(%rip), %xmm0   # 0x2c7038
callq 0x1163f0
mulsd 0x1ac0a7(%rip), %xmm0   # 0x2c7028
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
divsd 0x1ac09d(%rip), %xmm0   # 0x2c7038
callq 0x1163f0
mulsd 0x1ac098(%rip), %xmm0   # 0x2c7040
mulsd 0x40(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_bsm_benchmark.cpp
// Function: double bsm_model<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, double, double, double, double)
inline T bsm_model(const std::string& callput_flag, const T s, const T k, const T t, const T r, const T v)
{
   using namespace std;
   using namespace exprtk::details::numeric;

   const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
   const T d2 = d1 - v * sqrt(t);

   if (callput_flag == "call")
      return s * ncdf(d1) - k * exp(-r * t) * ncdf(d2);
   else if (callput_flag == "put")
      return k * exp(-r * t) * ncdf(-d2) - s * ncdf(-d1);
   else
      return T(0);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movsd %xmm4, 0x10(%rsp)
movaps %xmm3, 0x30(%rsp)
movsd %xmm2, 0x8(%rsp)
movq %rdi, %rbx
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
divsd %xmm1, %xmm0
callq 0x1160f0
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0xd3e(%rip), %xmm1      # 0x2c7028
addsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm3, %xmm3
sqrtsd %xmm2, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm2
movapd %xmm3, %xmm0
jae 0x2c6338
movapd %xmm2, %xmm0
movsd %xmm1, 0x18(%rsp)
movsd %xmm3, 0x48(%rsp)
callq 0x116230
xorpd %xmm4, %xmm4
movsd 0x48(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
divsd %xmm0, %xmm1
ucomisd %xmm4, %xmm2
movsd %xmm1, 0x18(%rsp)
jae 0x2c6363
movsd 0x8(%rsp), %xmm0
callq 0x116230
movsd 0x18(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x10(%rsp), %xmm0
mulsd %xmm3, %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
leaq 0x9731(%rip), %rsi      # 0x2cfab3
movq %rbx, %rdi
callq 0x116460
testl %eax, %eax
je 0x2c63ae
leaq 0x5d1c(%rip), %rsi      # 0x2cc0b1
movq %rbx, %rdi
callq 0x116460
testl %eax, %eax
je 0x2c642b
xorpd %xmm0, %xmm0
jmp 0x2c649e
movsd 0x18(%rsp), %xmm0
divsd 0xc74(%rip), %xmm0      # 0x2c7030
callq 0x1163f0
mulsd 0xc5f(%rip), %xmm0      # 0x2c7028
movsd %xmm0, 0x18(%rsp)
movapd 0x30(%rsp), %xmm0
xorpd 0xd33(%rip), %xmm0      # 0x2c7110
mulsd 0x8(%rsp), %xmm0
callq 0x1160b0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
divsd 0xc34(%rip), %xmm0      # 0x2c7030
callq 0x1163f0
mulsd 0xc1f(%rip), %xmm0      # 0x2c7028
movsd 0x8(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
jmp 0x2c649e
movapd 0x30(%rsp), %xmm0
xorpd 0xcd7(%rip), %xmm0      # 0x2c7110
mulsd 0x8(%rsp), %xmm0
callq 0x1160b0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
divsd 0xbda(%rip), %xmm0      # 0x2c7038
callq 0x1163f0
mulsd 0xbbd(%rip), %xmm0      # 0x2c7028
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
divsd 0xbb3(%rip), %xmm0      # 0x2c7038
callq 0x1163f0
mulsd 0xbae(%rip), %xmm0      # 0x2c7040
mulsd 0x28(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/Buf.cpp
// Function: Buf::Buf()
Buf::Buf() {
	b_flags = 0;
	b_forw = NULL;
	b_back = NULL;
	b_wcount = 0;
	b_addr = NULL;
	b_blkno = -1;
	b_error = -1;
	b_resid = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, (%rdi)
movq $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movl %eax, 0x18(%rdi)
movq $-0x1, 0x28(%rdi)
movl %eax, 0x30(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Initialize()
void BufferManager::Initialize()
{
	for (int i = 0; i < NBUF; ++i) 
	{
		if (i) 
		{
			m_Buf[i].b_forw = m_Buf + i - 1;
		}
		else 
		{
			m_Buf[i].b_forw = bFreeList;
			bFreeList->b_back = m_Buf + i;
		}

		if (i + 1 < NBUF) 
		{
			m_Buf[i].b_back = m_Buf + i + 1;
		}
		else 
		{
			m_Buf[i].b_back = bFreeList;
			bFreeList->b_forw = m_Buf + i;
		}
		m_Buf[i].b_addr = Buffer[i];
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
leaq 0x8(%rdi), %rcx
movl $0x15e8, %edx           # imm = 0x15E8
xorl %esi, %esi
testq %rsi, %rsi
je 0x38a1
leaq (%rdi,%rsi), %r8
addq $-0x30, %r8
movq %r8, 0x40(%r8)
jmp 0x38a9
movq %rax, 0x10(%rdi)
movq %rcx, 0x10(%rax)
cmpq $0x15a8, %rsi           # imm = 0x15A8
jne 0x38c4
leaq (%rdi,%rsi), %r8
addq $0x8, %r8
movq %rax, 0x10(%r8)
movq %r8, 0x8(%rax)
jmp 0x38d0
leaq (%rdi,%rsi), %r8
addq $0x40, %r8
movq %r8, -0x28(%r8)
leaq (%rdi,%rdx), %r8
movq %r8, 0x28(%rdi,%rsi)
addq $0x38, %rsi
addq $0x200, %rdx            # imm = 0x200
cmpq $0x15e0, %rsi           # imm = 0x15E0
jne 0x388e
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::GetBlk(int)
Buf* BufferManager::GetBlk(int blkno)
{
	Buf* bp;
	// User& u = globalUser;

	if (m_map.find(blkno) != m_map.end())
	{
		bp = m_map[blkno];
		Bdetach(bp);
		return bp;
	}

	// �����������ɶ���
	bp = bFreeList->b_back;
	if (bp == bFreeList)
	{
		cout << "bFreeList���в���" << endl;
		return NULL;
	}

	Bdetach(bp);
	m_map.erase(bp->b_blkno);

	if (bp->b_flags & Buf::B_DELWRI) {
		m_DeviceManager->write(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);
	}

	bp->b_flags &= ~(Buf::B_DELWRI | Buf::B_DONE);
	bp->b_blkno = blkno;
	m_map[blkno] = bp;

	return bp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x1c(%rbp)
movslq %esi, %rax
movq 0xddf0(%rdi), %rdi
movq 0xddf8(%rbx), %r8
xorl %r10d, %r10d
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x395f
movq (%rax), %r9
movq %rax, %r10
cmpl %esi, 0x8(%r9)
je 0x395f
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x395c
movslq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0x395f
movq %r11, %r10
cmpl %esi, %edi
jne 0x3931
jmp 0x395f
xorl %r10d, %r10d
leaq 0xddf0(%rbx), %r15
testq %r10, %r10
je 0x39aa
cmpq $0x0, (%r10)
je 0x39aa
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x3ec2
movq (%rax), %r14
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x3a68
movq 0x8(%r14), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%r14), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
jmp 0x3a68
movq (%rbx), %rax
movq 0x10(%rax), %r14
cmpq %rax, %r14
je 0x3a23
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x39d7
movq 0x8(%r14), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%r14), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x4170
testb $-0x80, (%r14)
je 0x3a08
movq 0xdde8(%rbx), %rdi
movq 0x20(%r14), %rsi
movl 0x28(%r14), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x42f2
andb $0x7b, (%r14)
leaq -0x1c(%rbp), %rsi
movl (%rsi), %eax
movl %eax, 0x28(%r14)
movq %r15, %rdi
callq 0x3ec2
movq %r14, (%rax)
jmp 0x3a68
movq 0x959e(%rip), %rbx      # 0xcfc8
leaq 0x55d3(%rip), %rsi      # 0x9004
movl $0x11, %edx
movq %rbx, %rdi
callq 0x3260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bdetach(Buf*)
void BufferManager::Bdetach(Buf *bp)
{
	if (bp->b_back == NULL) {
		return;
	}

	bp->b_forw->b_back = bp->b_back;
	bp->b_back->b_forw = bp->b_forw;

	bp->b_back = NULL;
	bp->b_forw = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x3a9a
movq 0x8(%rsi), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Brelse(Buf*)
void BufferManager::Binsert(Buf* bp)
{
	if (bp->b_back != NULL) {
		return;
	}

	bp->b_forw = bFreeList->b_forw;
	bp->b_back = bFreeList;

	bFreeList->b_forw->b_back = bp;
	bFreeList->b_forw = bp;
}

// Assembly:
cmpq $0x0, 0x10(%rsi)
je 0x3aa4
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq 0x8(%rax), %rcx
movq %rsi, 0x10(%rcx)
movq %rsi, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bread(int)
Buf* BufferManager::Bread(int blkno)
{
	Buf* bp;
	bp = this->GetBlk(blkno);
	if (bp->b_flags & (Buf::B_DONE | Buf::B_DELWRI))
	{
		return bp;
	}

	m_DeviceManager->read(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);

	bp->b_flags |= Buf::B_DONE;
	
	return bp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x38f0
movq %rax, %rbx
testb $-0x7c, (%rax)
jne 0x3b28
movq 0xdde8(%r14), %rdi
movq 0x20(%rbx), %rsi
movl 0x28(%rbx), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x4334
orb $0x4, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bwrite(Buf*)
void BufferManager::Bwrite(Buf* bp)
{
	bp->b_flags &= ~(Buf::B_DELWRI);
	m_DeviceManager->write(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);
	bp->b_flags |= Buf::B_DONE;
	Brelse(bp);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
andb $0x7f, (%rsi)
movq 0xdde8(%rdi), %rdi
movq 0x20(%rsi), %rsi
movl 0x28(%rbx), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x42f2
orb $0x4, (%rbx)
cmpq $0x0, 0x10(%rbx)
jne 0x3b83
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq 0x8(%rax), %rcx
movq %rbx, 0x10(%rcx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bformat()
void BufferManager::Bformat()
{
	Buf b;
	for (int cnt = 0; cnt < NBUF; cnt++) 
	{
		memcpy(m_Buf + cnt, &b, sizeof(Buf));
	}
	Initialize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x40(%rbp), %rdi
callq 0x384c
movl $0x8, %eax
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rbx,%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups -0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rbx,%rax)
movups %xmm1, 0x10(%rbx,%rax)
movups %xmm0, (%rbx,%rax)
addq $0x38, %rax
cmpq $0x15e8, %rax           # imm = 0x15E8
jne 0x3ba2
movq %rbx, %rdi
callq 0x387c
leaq -0x40(%rbp), %rdi
callq 0x3874
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bdwrite(Buf*)
void BufferManager::Bdwrite(Buf* bp)
{
	/* ����B_DONE������������ʹ�øô��̿����� */
	bp->b_flags |= (Buf::B_DELWRI | Buf::B_DONE);
	this->Brelse(bp);
	return;
}

// Assembly:
orb $-0x7c, (%rsi)
cmpq $0x0, 0x10(%rsi)
je 0x3bf5
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq 0x8(%rax), %rcx
movq %rsi, 0x10(%rcx)
movq %rsi, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bflush()
void BufferManager::Bflush()
{
	Buf* bp = NULL;

	for (int cnt = 0; cnt < NBUF; cnt++) 
	{
		bp = m_Buf + cnt;
		if (bp->b_flags & Buf::B_DELWRI) {
			bp->b_flags &= ~(Buf::B_DELWRI);
			m_DeviceManager->write(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);
			bp->b_flags |= (Buf::B_DONE);
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movl 0x8(%rbx,%r14), %eax
testb %al, %al
jns 0x3c73
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movl %eax, 0x8(%rbx,%r14)
movq 0xdde8(%rbx), %rdi
movq 0x28(%rbx,%r14), %rsi
movl 0x30(%rbx,%r14), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x42f2
orb $0x4, 0x8(%rbx,%r14)
addq $0x38, %r14
cmpq $0x15e0, %r14           # imm = 0x15E0
jne 0x3c39
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/DeviceManager.cpp
// Function: DeviceManager::Construct()
void DeviceManager::Construct() {
    fp = fopen(DISK_FILE_NAME, "wb+");
    if (fp == NULL) {
        printf("�򿪻��½��ļ�%sʧ�ܣ�", DISK_FILE_NAME);
        exit(-1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8f80(%rip), %rdi      # 0xd238
leaq 0x4d62(%rip), %rsi      # 0x9021
callq 0x3270
movq %rax, (%rbx)
testq %rax, %rax
je 0x42d3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8f5e(%rip), %rsi      # 0xd238
leaq 0x4d44(%rip), %rdi      # 0x9025
xorl %eax, %eax
callq 0x3060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::FileManager()
FileManager::FileManager() 
{
    m_FileSystem = &globalFileSystem;
    m_OpenFileTable = &globalOpenFileTable;
    m_InodeTable = &globalINodeTable;
    rootDirInode = m_InodeTable->IGet(0);
    rootDirInode->i_count += 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x179a0(%rip), %rax     # 0x1bde8
movq %rax, 0x8(%rdi)
leaq 0x16c35(%rip), %rax     # 0x1b088
movq %rax, 0x18(%rdi)
leaq 0x179a2(%rip), %rdi     # 0x1be00
movq %rdi, 0x10(%rbx)
xorl %esi, %esi
callq 0x5ee2
movq %rax, (%rbx)
addl $0xff, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Open1(Inode*, int, int)
void FileManager::Open1(Inode* pINode, int mode, int trf) 
{
    User& u = globalUser;

    /* ��creat�ļ���ʱ��������ͬ�ļ������ļ����ͷŸ��ļ���ռ�ݵ������̿� */
    if (1 == trf) 
    {
        pINode->ITrunc();
    }

    /* ���������ļ����ƿ�File�ṹ */
    File* pFile = this->m_OpenFileTable->FAlloc();
    if (NULL == pFile) 
    {
        this->m_InodeTable->IPut(pINode);
        return;
    }

    /* ���ô����ļ���ʽ������File�ṹ���ڴ�Inode�Ĺ�����ϵ */
    pFile->f_flag = mode & (File::FREAD | File::FWRITE);
    pFile->f_inode = pINode;

    /* Ϊ�򿪻��ߴ����ļ��ĸ�����Դ���ѳɹ����䣬�������� */
    if (u.u_error == 0) 
    {
        return;
    }
    else {  /* �����������ͷ���Դ */
        /* �ͷŴ����ļ������� */
        int fd = u.u_ar0[User::EAX];
        if (fd != -1) 
        {
            u.u_ofiles.SetF(fd, NULL);
            /* �ݼ�File�ṹ��Inode�����ü��� ,File�ṹû���� f_countΪ0�����ͷ�File�ṹ��*/
            pFile->f_count--;
        }
        this->m_InodeTable->IPut(pINode);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %ecx
jne 0x47d1
movq %rbx, %rdi
callq 0x5acc
movq 0x18(%r14), %rdi
callq 0x5d34
testq %rax, %rax
je 0x481c
movq %rax, %r15
andl $0x3, %r12d
movl %r12d, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x193e4(%rip), %rax     # 0x1dbd8
cmpl $0x0, 0x10c8(%rax)
je 0x4830
movl 0x20(%rax), %esi
cmpl $-0x1, %esi
je 0x481c
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x87bf(%rip), %rdi      # 0xcfd0
xorl %edx, %edx
callq 0x4418
decl 0x4(%r15)
movq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5dfa
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Creat()
void FileManager::Creat() 
{
    Inode* pINode;
    User& u = globalUser;
    unsigned int newACCMode = u.u_arg[1];

    /* ����Ŀ¼��ģʽΪ1����ʾ����������Ŀ¼����д���������� */
    pINode = this->NameI(FileManager::CREATE);

    /* û���ҵ���Ӧ��Inode����NameI���� */
    if (NULL == pINode) 
    {
        if (u.u_error)
            return;
        pINode = this->MakNode(newACCMode);
        if (NULL == pINode)
            return;

        /*
         * ������ϣ�������ֲ����ڣ�ʹ�ò���trf = 2������open1()��
         * ����Ҫ����Ȩ�޼��飬��Ϊ�ոս������ļ���Ȩ�޺ʹ�������mode
         * ����ʾ��Ȩ��������һ���ġ�
         */
        this->Open1(pINode, File::FWRITE, 2);
        return;
    }

    /* ����NameI()�������Ѿ�����Ҫ�������ļ��������ո��ļ������㷨ITrunc()����UIDû�иı�
     * ԭ��UNIX���������������ļ�����ȥ�����½����ļ�һ����Ȼ�������ļ������ߺ�����Ȩ��ʽû�䡣
     * Ҳ����˵creatָ����RWX������Ч��
     * ������Ϊ���ǲ������ģ�Ӧ�øı䡣
     * ���ڵ�ʵ�֣�creatָ����RWX������Ч */
    this->Open1(pINode, File::FWRITE, 1);
    pINode->i_mode |= newACCMode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x19389(%rip), %r12     # 0x1dbd8
movl 0x1024(%r12), %r14d
movl $0x1, %esi
callq 0x44bc
testq %rax, %rax
je 0x4884
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x47b0
orl %r14d, 0x4(%r15)
jmp 0x488f
cmpl $0x0, 0x10c8(%r12)
je 0x4898
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0x48c6
testq %rax, %rax
je 0x488f
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
movl $0x2, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x47b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::MakNode(unsigned int)
Inode* FileManager::MakNode(unsigned int mode) 
{
    Inode* pINode;
    User& u = globalUser;

    /* ����һ������DiskInode������������ȫ������ */
    pINode = this->m_FileSystem->IAlloc();
    if (NULL == pINode) 
    {
        return NULL;
    }

    pINode->i_flag |= (Inode::IACC | Inode::IUPD);
    pINode->i_mode = mode | Inode::IALLOC;
    pINode->i_nlink = 1;

    /* ��Ŀ¼��д��u.u_u_dent������д��Ŀ¼�ļ� */
    this->WriteDir(pINode);
    return pINode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x51c2
testq %rax, %rax
je 0x4909
movq %rax, %rbx
orb $0x6, (%rax)
orl $0x8000, %r15d          # imm = 0x8000
movl %r15d, 0x4(%rax)
movl $0x1, 0xc(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x491a
jmp 0x490b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop