LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f8d
leaq 0x40dc(%rip), %rcx      # 0xa048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbp
jmp 0x6c0a
popq %rbp
jmp 0x71d8
popq %rbp
jmp 0x6d4c
popq %rbp
jmp 0x6dac
movl $0x5, 0x68(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::UpdatePlayerInformation(PlayerInformation&)
void UpdatePlayerInformation(PlayerInformation &info) {
        info.score += gain_score;
        gain_score = 0;
        info.chain_number = chain_number;
        if (info.max_chain_number < chain_number)
            info.max_chain_number = chain_number;
        info.obstacle_number_taken = obstacle_number_taken;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x6c(%rdi), %eax
addl %eax, (%rsi)
andl $0x0, 0x6c(%rdi)
movl 0x70(%rdi), %eax
movl %eax, 0x4(%rsi)
cmpl %eax, 0x8(%rsi)
jge 0x5fb1
movl %eax, 0x8(%rsi)
movl 0x74(%rdi), %eax
movl %eax, 0xc(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x190(%rbp), %r15
movq %r15, %rdi
callq 0x3360
movl (%r14), %esi
movq %r15, %rdi
callq 0x3460
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x3310
movl 0x4(%r14), %esi
leaq -0x190(%rbp), %rdi
callq 0x3460
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x3310
movl 0x8(%r14), %esi
leaq -0x190(%rbp), %rdi
callq 0x3460
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x3310
movl 0xc(%r14), %esi
leaq -0x190(%rbp), %rdi
callq 0x3460
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x3400
leaq -0x190(%rbp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x190(%rbp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x30(%rbp)
leaq -0x1c8(%rbp), %r15
movq %r15, %rdi
callq 0x3360
xorl %r12d, %r12d
movq %r14, %r13
cmpq $0xd, %r12
je 0x6284
xorl %ebx, %ebx
cmpq $0x6, %rbx
je 0x627b
movb (%r13,%rbx), %al
addb $0x61, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x3310
incq %rbx
jmp 0x625e
incq %r12
addq $0x6, %r13
jmp 0x6256
movl 0x68(%r14), %esi
leaq -0x1c8(%rbp), %rdi
callq 0x3460
movq -0x30(%rbp), %rbx
movq 0x50(%r14), %rsi
testq %rsi, %rsi
je 0x62f2
leaq -0x50(%rbp), %rdi
callq 0x634c
leaq -0x1c8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3220
leaq -0x50(%rbp), %rdi
callq 0x3140
movl 0x60(%r14), %esi
leaq -0x1c8(%rbp), %rdi
callq 0x3460
leaq 0x4348(%rip), %rsi      # 0xa622
movq %rax, %rdi
callq 0x3280
movl 0x64(%r14), %esi
leaq -0x1c8(%rbp), %rdi
callq 0x3460
leaq -0x1c0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3400
leaq -0x1c8(%rbp), %rdi
callq 0x3080
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 -0x50(%rbp), %rdi
callq 0x3140
jmp 0x6337
jmp 0x6334
jmp 0x6334
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3470
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x190(%rbp), %r15
movq %r15, %rdi
callq 0x3360
movb (%r14), %al
addb $0x61, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x3310
movb 0x1(%r14), %al
addb $0x61, %al
movsbl %al, %esi
leaq -0x190(%rbp), %rdi
callq 0x3310
movl 0x4(%r14), %esi
leaq -0x190(%rbp), %rdi
callq 0x3460
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x3400
leaq -0x190(%rbp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x190(%rbp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3470
nop
// File: /workspace/github_cpp_makefile_star2_O2/Leeingnyo[P]newPuyoC/./player_information.h
// Function: PlayerInformation::Deserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Deserialize(std::string data) {
        std::string buf;
        std::stringstream ss(data);
        std::vector<std::string> tokens;
        while (ss >> buf)
            tokens.push_back(buf);
        score = std::stoi(tokens[0]);
        chain_number = std::stoi(tokens[1]);
        max_chain_number = std::stoi(tokens[2]);
        obstacle_number_taken = std::stoi(tokens[3]);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, %rbx
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1e8(%rbp), %rdi
pushq $0x18
popq %rdx
callq 0x3410
leaq -0x40(%rbp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq -0x1e8(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3340
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x645f
movq %r14, %rdi
movq %r12, %rsi
callq 0x7f62
jmp 0x6439
movq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x611a
movl %eax, (%rbx)
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x611a
movl %eax, 0x4(%rbx)
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x611a
movl %eax, 0x8(%rbx)
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x611a
movl %eax, 0xc(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7f9e
leaq -0x1e8(%rbp), %rdi
callq 0x31d0
leaq -0x60(%rbp), %rdi
callq 0x3140
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x64fb
jmp 0x64e3
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7f9e
leaq -0x1e8(%rbp), %rdi
callq 0x31d0
leaq -0x60(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O2/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 0x67c9
pushq $0x2
popq %r13
subl %eax, %r13d
movl %ecx, %eax
leaq 0x38ec(%rip), %rcx      # 0xa0b0
movl (%rcx,%rax,4), %ecx
jmp 0x67cf
pushq $-0x1
popq %rcx
xorl %r13d, %r13d
testl %r12d, %r12d
jle 0x6809
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 0x97d3(%rip), %rdi      # 0xffc8
callq 0x3c46
movq %rbx, %rdi
callq 0x6850
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rsi
movl %ecx, %eax
addl %r12d, %eax
jle 0x6841
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 0x9797(%rip), %rdi      # 0xffc8
callq 0x3c46
incq %rbx
movq %rbx, %rdi
callq 0x6850
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6c3c
movl 0x4(%rax), %esi
leal -0x1(%rsi), %edx
cmpl $0x2, %edx
ja 0x6c40
movl %edx, %ecx
leaq 0x347e(%rip), %rdx      # 0xa0b0
movl (%rdx,%rcx,4), %edx
pushq $0x2
popq %rcx
subl %esi, %ecx
jmp 0x6c43
xorl %edx, %edx
jmp 0x6c43
pushq $-0x1
popq %rdx
movl 0x80(%rbx), %esi
leal 0x1(%rsi), %edi
movl %edi, 0x80(%rbx)
cmpl 0x7c(%rbx), %esi
jle 0x6ceb
andl $0x0, 0x80(%rbx)
movslq 0x64(%rbx), %r8
cmpq $0xc, %r8
jge 0x6cae
leaq 0x1(%r8), %rdi
movl 0x60(%rbx), %esi
movslq %esi, %r9
imulq $0x6, %rdi, %r10
addq %rbx, %r10
cmpb $0x0, (%r9,%r10)
jne 0x6cb4
leal (%r8,%rdx), %r10d
cmpl $0xb, %r10d
jg 0x6cb4
incl %r10d
movslq %r10d, %r10
leal (%rsi,%rcx), %r11d
movslq %r11d, %r11
imulq $0x6, %r10, %r10
addq %rbx, %r10
cmpb $0x0, (%r11,%r10)
jne 0x6cb4
movl %edi, 0x64(%rbx)
jmp 0x6ceb
movl 0x60(%rbx), %esi
movslq %esi, %r9
leaq 0x50(%rbx), %rdi
movb (%rax), %r10b
imulq $0x6, %r8, %r11
addq %rbx, %r11
movb %r10b, (%r9,%r11)
addl %r8d, %edx
js 0x6cdf
movb 0x1(%rax), %al
movl %edx, %edx
addl %ecx, %esi
movslq %esi, %rcx
imulq $0x6, %rdx, %rdx
addq %rbx, %rdx
movb %al, (%rcx,%rdx)
callq 0x7356
movl $0x1, 0x68(%rbx)
movl 0x88(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x84(%rbx), %eax
jg 0x6d03
testl %eax, %eax
jle 0x6d09
incl %eax
movl %eax, %ecx
movl %ecx, 0x88(%rbx)
movl 0x90(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x8c(%rbx), %eax
jg 0x6d21
testl %eax, %eax
jle 0x6d27
incl %eax
movl %eax, %ecx
movl %ecx, 0x90(%rbx)
movl 0x98(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x94(%rbx), %eax
jg 0x6d3f
testl %eax, %eax
jle 0x6d45
incl %eax
movl %eax, %ecx
movl %ecx, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6daa
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xa8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xa8(%rdi)
cmpl 0xa4(%rdi), %eax
jl 0x6da4
andl $0x0, 0xa8(%rbx)
movq %rbx, %rdi
callq 0x7384
testb %al, %al
jne 0x6da4
movl $0x2, 0x68(%rbx)
andl $0x0, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::ShiftDown()
bool ShiftDown() {
        bool isChanged = false;
        for (int i = MAP_HEIGHT - 1; i > 0; i--) {
            for (int j = 0; j < MAP_WIDTH; j++) {
                if (map[i][j].IsBlank() && !map[i - 1][j].IsBlank()) {
                    map[i][j] = map[i - 1][j];
                    map[i - 1][j] = Puyo();
                    isChanged = true;
                }
            }
        }
        return isChanged;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $0x48, %rdi
movabsq $0xc, %rcx
xorl %eax, %eax
movabsq $-0x6, %rdx
subq $0x1, %rcx
jb 0x73d6
movq %rdx, %rsi
testq %rsi, %rsi
je 0x73d0
cmpb $0x0, 0x6(%rdi,%rsi)
jne 0x73cb
movb (%rdi,%rsi), %r8b
testb %r8b, %r8b
je 0x73cb
movb %r8b, 0x6(%rdi,%rsi)
movb $0x0, (%rdi,%rsi)
movb $0x1, %al
incq %rsi
jmp 0x73ab
addq $-0x6, %rdi
jmp 0x73a2
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x80(%rdi)
leaq -0x13a0(%rbp), %r14
movq %r14, %rdi
callq 0x8630
movq %r14, %rdi
callq 0x3380
movl %eax, %esi
leaq -0x2728(%rbp), %rdi
callq 0x8708
xorl %r15d, %r15d
leaq -0x2728(%rbp), %r14
cmpq $0x10, %r15
je 0x85fc
movq %r14, %rdi
callq 0x8686
movq %rax, (%rbx,%r15,8)
incq %r15
jmp 0x85e5
leaq -0x13a0(%rbp), %rdi
callq 0x86f4
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8618
movq %rax, %rbx
leaq -0x13a0(%rbp), %rdi
callq 0x86f4
movq %rbx, %rdi
callq 0x3470
nop
// File: /workspace/github_cpp_makefile_star2_O2/Leeingnyo[P]newPuyoC/./board.h
// Function: Board::Board()
Board() {
        gain_score = 0;
        chain_number = 0;
        obstacle_number_taken = 0;
        obstacle_number_to_send = 0;
        
        gravity_t = 0;
        rotate_t = 0;
        move_t = 0;
        down_t = 0;
        drop_predelay_t = 0;
        drop_t = 0;
        chaining_t = 0;
        
        state = State::IDLE;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x3e(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x50(%rdi)
movaps 0x166b(%rip), %xmm1     # 0xa0d0
movups %xmm1, 0x7c(%rdi)
movaps 0x1670(%rip), %xmm1     # 0xa0e0
movups %xmm1, 0x8c(%rdi)
movaps 0x1672(%rip), %xmm1     # 0xa0f0
movups %xmm1, 0x9c(%rdi)
movq $0x1e, 0xac(%rdi)
movups %xmm0, 0x68(%rdi)
andl $0x0, 0x78(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10e100
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x125d61(%rip), %xmm1   # 0x237018
addsd 0x30(%rsp), %xmm1
movsd (%rsp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm3, %xmm2
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
movapd %xmm2, %xmm0
jae 0x111302
movsd (%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x10e250
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 0x111331
movsd (%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x10e250
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x1147b4
movsd %xmm0, 0x10(%rsp)
movapd 0x30(%rsp), %xmm0
xorpd 0x125d7a(%rip), %xmm0   # 0x2370e0
mulsd (%rsp), %xmm0
callq 0x10e0d0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x1147b4
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_O2/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 $0x58, %rsp
movsd %xmm4, (%rsp)
movaps %xmm3, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
divsd %xmm1, %xmm0
callq 0x10e100
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x125c34(%rip), %xmm1   # 0x237018
addsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm2, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm2
movapd %xmm3, %xmm0
jae 0x11142f
movapd %xmm2, %xmm0
movapd %xmm1, 0x20(%rsp)
movsd %xmm3, 0x30(%rsp)
callq 0x10e250
xorpd %xmm4, %xmm4
movsd 0x30(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movapd 0x20(%rsp), %xmm1
mulsd (%rsp), %xmm0
divsd %xmm0, %xmm1
ucomisd %xmm4, %xmm2
movapd %xmm1, 0x20(%rsp)
jae 0x11145d
movapd %xmm2, %xmm0
callq 0x10e250
movsd 0x8(%rsp), %xmm2
movapd 0x20(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd (%rsp), %xmm0
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm1
movapd %xmm1, 0x30(%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x125c62(%rip), %xmm0   # 0x2370e0
mulsd %xmm2, %xmm0
callq 0x10e0d0
mulsd 0x48(%rsp), %xmm0
movsd %xmm0, (%rsp)
movaps 0x30(%rsp), %xmm0
xorps 0x125c42(%rip), %xmm0   # 0x2370e0
callq 0x1147b4
movsd %xmm0, 0x10(%rsp)
movapd 0x20(%rsp), %xmm0
xorpd 0x125c29(%rip), %xmm0   # 0x2370e0
callq 0x1147b4
mulsd 0x50(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x58, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x60, %rsp
movsd %xmm4, 0x10(%rsp)
movaps %xmm3, 0x40(%rsp)
movsd %xmm2, 0x8(%rsp)
movq %rdi, %rbx
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
divsd %xmm1, %xmm0
callq 0x10e100
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x861(%rip), %xmm1      # 0x237018
addsd 0x40(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm2, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm2
movapd %xmm3, %xmm0
jae 0x236802
movapd %xmm2, %xmm0
movapd %xmm1, 0x20(%rsp)
movsd %xmm3, 0x58(%rsp)
callq 0x10e250
xorpd %xmm4, %xmm4
movsd 0x58(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movapd 0x20(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
divsd %xmm0, %xmm1
ucomisd %xmm4, %xmm2
movapd %xmm1, 0x20(%rsp)
jae 0x23682d
movsd 0x8(%rsp), %xmm0
callq 0x10e250
movapd 0x20(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x10(%rsp), %xmm0
mulsd %xmm3, %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
leaq 0x9ac5(%rip), %rsi      # 0x240311
movq %rbx, %rdi
callq 0x23693f
testb %al, %al
je 0x2368b7
movaps 0x20(%rsp), %xmm0
callq 0x1147b4
movsd %xmm0, 0x20(%rsp)
movapd 0x40(%rsp), %xmm0
xorpd 0x86a(%rip), %xmm0      # 0x2370e0
mulsd 0x8(%rsp), %xmm0
callq 0x10e0d0
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm0
callq 0x1147b4
movsd 0x8(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
subsd %xmm1, %xmm0
jmp 0x236939
leaq 0x6023(%rip), %rsi      # 0x23c8e1
movq %rbx, %rdi
callq 0x23693f
testb %al, %al
je 0x236935
movapd 0x40(%rsp), %xmm0
xorpd 0x808(%rip), %xmm0      # 0x2370e0
mulsd 0x8(%rsp), %xmm0
callq 0x10e0d0
mulsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movaps 0x10(%rsp), %xmm0
xorps 0x7e5(%rip), %xmm0      # 0x2370e0
callq 0x1147b4
movsd %xmm0, 0x10(%rsp)
movapd 0x20(%rsp), %xmm0
xorpd 0x7cc(%rip), %xmm0      # 0x2370e0
callq 0x1147b4
mulsd 0x38(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x236939
xorpd %xmm0, %xmm0
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rdi)
andq $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
andl $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
orq $-0x1, 0x28(%rdi)
andl $0x0, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x15e8(%rdi), %rax
leaq 0x8(%rdi), %rcx
leaq -0x30(%rdi), %rdx
movq (%rdi), %rsi
leaq 0x40(%rdi), %r8
leaq 0x15b0(%rdi), %r9
xorl %r14d, %r14d
movl $0x1, %r10d
movl $0x64, %r11d
movabsq $0x63, %rbx
cmpl $0x64, %r14d
jae 0x38dd
testl %r14d, %r14d
je 0x389d
movl %r14d, %r15d
imulq $0x38, %r15, %r12
leaq (%rdx,%r12), %r13
movq %r13, 0x8(%rcx,%r12)
cmpl $0x63, %r14d
je 0x38ba
incl %r14d
jmp 0x38ab
movq %rsi, 0x10(%rdi)
movq %rcx, 0x10(%rsi)
xorl %r15d, %r15d
movl %r10d, %r14d
imulq $0x38, %r15, %r12
leaq (%r8,%r12), %r13
movq %r13, 0x10(%rcx,%r12)
jmp 0x38cb
movq %rsi, 0x15c0(%rdi)
movq %r9, 0x8(%rsi)
movq %rbx, %r15
movl %r11d, %r14d
imulq $0x38, %r15, %r12
shlq $0x9, %r15
addq %rax, %r15
movq %r15, 0x20(%rcx,%r12)
jmp 0x3877
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
leaq -0x1c(%rbp), %rax
movl %esi, (%rax)
leaq 0xddf0(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3dc8
testq %rax, %rax
je 0x394a
leaq -0x1c(%rbp), %rsi
movq %r14, %rdi
callq 0x3e52
movq (%rax), %rbx
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x39e2
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rbx), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x39e2
movq (%r15), %rax
movq 0x10(%rax), %rbx
cmpq %rax, %rbx
je 0x39c5
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3976
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rbx), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x41b4
movl (%rbx), %eax
testb %al, %al
jns 0x39a8
movq 0xdde8(%r15), %rdi
movq 0x20(%rbx), %rsi
movl 0x28(%rbx), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x4358
movl (%rbx), %eax
andl $0xffffff7b, %eax       # imm = 0xFFFFFF7B
movl %eax, (%rbx)
leaq -0x1c(%rbp), %rsi
movl (%rsi), %eax
movl %eax, 0x28(%rbx)
movq %r14, %rdi
callq 0x3e52
movq %rbx, (%rax)
jmp 0x39e2
movq 0x85f4(%rip), %rdi      # 0xbfc0
leaq 0x4631(%rip), %rsi      # 0x8004
callq 0x31e0
movq %rax, %rdi
callq 0x3100
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a14
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_O2/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Binsert(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 0x3a28
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38e8
movq %rax, %rbx
testb $-0x7c, (%rax)
jne 0x3a7e
movq 0xdde8(%r14), %rdi
movq 0x20(%rbx), %rsi
movl 0x28(%rbx), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x4398
orb $0x4, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4358
orb $0x4, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a20
// File: /workspace/github_cpp_makefile_star2_O2/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 0x380c
pushq $0x8
popq %rax
cmpq $0x15e8, %rax           # imm = 0x15E8
je 0x3b0f
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
jmp 0x3ade
movq %rbx, %rdi
callq 0x3834
leaq -0x40(%rbp), %rdi
callq 0x382e
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x15e0, %r14           # imm = 0x15E0
je 0x3ba2
movl 0x8(%rbx,%r14), %eax
testb %al, %al
jns 0x3b9c
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 0x4358
orb $0x4, 0x8(%rbx,%r14)
addq $0x38, %r14
jmp 0x3b59
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7f18(%rip), %rdi      # 0xc238
leaq 0x3cfb(%rip), %rsi      # 0x8022
callq 0x3260
movq %rax, (%rbx)
testq %rax, %rax
je 0x433b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x7ef6(%rip), %rsi      # 0xc238
leaq 0x3cdd(%rip), %rdi      # 0x8026
xorl %eax, %eax
callq 0x3050
pushq $-0x1
popq %rdi
callq 0x3270
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16948(%rip), %rax     # 0x1ade8
movq %rax, 0x8(%rdi)
leaq 0x15bdd(%rip), %rax     # 0x1a088
movq %rax, 0x18(%rdi)
leaq 0x1694a(%rip), %rdi     # 0x1ae00
movq %rdi, 0x10(%rbx)
xorl %esi, %esi
callq 0x5dfa
movq %rax, (%rbx)
addl $0xff, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4829
movq %rbx, %rdi
callq 0x59f0
movq 0x18(%r14), %rdi
callq 0x5c78
testq %rax, %rax
je 0x4874
movq %rax, %r15
andl $0x3, %r12d
movl %r12d, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x1838c(%rip), %rax     # 0x1cbd8
cmpl $0x0, 0x10c8(%rax)
je 0x4888
movl 0x20(%rax), %esi
cmpl $-0x1, %esi
je 0x4874
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x775f(%rip), %rdi      # 0xbfc8
xorl %edx, %edx
callq 0x4470
decl 0x4(%r15)
movq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5d14
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18331(%rip), %r12     # 0x1cbd8
movl 0x1024(%r12), %r14d
pushq $0x1
popq %rsi
callq 0x4514
testq %rax, %rax
je 0x48d6
movq %rax, %r15
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4808
orl %r14d, 0x4(%r15)
jmp 0x48e1
cmpl $0x0, 0x10c8(%r12)
je 0x48ea
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4912
testq %rax, %rax
je 0x48e1
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
movl %ecx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4808
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq 0x8(%rdi), %rdi
callq 0x51c4
movq %rax, %r14
testq %rax, %rax
je 0x4955
orb $0x6, (%r14)
orl $0x8000, %r15d          # imm = 0x8000
movl %r15d, 0x4(%r14)
movl $0x1, 0xc(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4964
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::WriteDir(Inode*)
void FileManager::WriteDir(Inode* pINode) 
{
    User& u = globalUser;

    /* ����Ŀ¼����Inode���Ų��� */
    u.u_dent.m_ino = pINode->i_number;

    /* ����Ŀ¼����pathname�������� */
    memcpy(u.u_dent.name, u.u_dbuf, DirectoryEntry::DIRSIZ);

    u.u_IOParam.m_Count = DirectoryEntry::DIRSIZ + 4;
    u.u_IOParam.m_Base = (unsigned char*)&u.u_dent;

    /* ��Ŀ¼��д�븸Ŀ¼�ļ� */
    u.u_pdir->WriteI();
    this->m_InodeTable->IPut(u.u_pdir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x14(%rsi), %eax
leaq 0x18260(%rip), %r14     # 0x1cbd8
movl %eax, 0x1068(%r14)
leaq 0x1068(%r14), %rax
movups 0x1088(%r14), %xmm0
movups %xmm0, 0x106c(%r14)
movups 0x1094(%r14), %xmm0
movups %xmm0, 0x1078(%r14)
movl $0x20, 0x13fc(%r14)
movq %rax, 0x13f0(%r14)
movq 0x1060(%r14), %rdi
callq 0x57f6
movq 0x10(%rbx), %rdi
movq 0x1060(%r14), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d14
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Close()
void FileManager::Close() 
{
    User& u = globalUser;
    int fd = u.u_arg[0];

    /* ��ȡ�����ļ����ƿ�File�ṹ */
    File* pFile = u.u_ofiles.GetF(fd);
    if (NULL == pFile) {
        return;
    }

    /* �ͷŴ����ļ�������fd���ݼ�File�ṹ���ü��� */
    u.u_ofiles.SetF(fd, NULL);
    this->m_OpenFileTable->CloseF(pFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x181ec(%rip), %rdi     # 0x1cbd8
movl 0x1020(%rdi), %r14d
addq $0x10d0, %rdi           # imm = 0x10D0
movl %r14d, %esi
callq 0x4446
testq %rax, %rax
je 0x4a36
movq %rax, %r15
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x75b2(%rip), %rdi      # 0xbfc8
movl %r14d, %esi
xorl %edx, %edx
callq 0x4470
movq 0x18(%rbx), %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cee
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::UnLink()
void FileManager::UnLink() 
{
    Inode* pINode;
    Inode* pDeleteINode;
    User& u = globalUser;

    pDeleteINode = this->NameI(FileManager::DELETE);
    if (NULL == pDeleteINode) 
    {
        return;
    }

    pINode = this->m_InodeTable->IGet(u.u_dent.m_ino);
    if (NULL == pINode) 
    {
        return;
    }

    /* д����������Ŀ¼�� */
    u.u_IOParam.m_Offset -= (DirectoryEntry::DIRSIZ + 4);
    u.u_IOParam.m_Base = (unsigned char*)&u.u_dent;
    u.u_IOParam.m_Count = DirectoryEntry::DIRSIZ + 4;

    u.u_dent.m_ino = 0;
    pDeleteINode->WriteI();

    /* �޸�inode�� */
    pINode->i_nlink--;
    pINode->i_flag |= Inode::IUPD;

    this->m_InodeTable->IPut(pDeleteINode);
    this->m_InodeTable->IPut(pINode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x4514
testq %rax, %rax
je 0x4ae2
movq %rax, %r14
movq 0x10(%rbx), %rdi
leaq 0x18169(%rip), %r12     # 0x1cbd8
movl 0x1068(%r12), %esi
callq 0x5dfa
testq %rax, %rax
je 0x4ae2
movq %rax, %r15
addl $-0x20, 0x13f8(%r12)
leaq 0x1068(%r12), %rax
movq %rax, 0x13f0(%r12)
movl $0x20, 0x13fc(%r12)
andl $0x0, 0x1068(%r12)
movq %r14, %rdi
callq 0x57f6
decl 0xc(%r15)
orb $0x2, (%r15)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x5d14
movq 0x10(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5d14
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Seek()
void FileManager::Seek() 
{
    File* pFile;
    User& u = globalUser;
    int fd = u.u_arg[0];

    pFile = u.u_ofiles.GetF(fd);
    if (NULL == pFile) 
    {
        return;  /* ��FILE�����ڣ�GetF���������� */
    }

    int m_Offset = u.u_arg[1];

    switch (u.u_arg[2]) 
    {
        /* ��дλ������Ϊm_Offset */
        case 0:
            pFile->f_offset = m_Offset;
            break;
            /* ��дλ�ü�m_Offset(�����ɸ�) */
        case 1:
            pFile->f_offset += m_Offset;
            break;
            /* ��дλ�õ���Ϊ�ļ����ȼ�m_Offset */
        case 2:
            pFile->f_offset = pFile->f_inode->i_size + m_Offset;
            break;
        default:
            cout << "seek " << u.u_arg[2] << "���������� \n";
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x180df(%rip), %rbx     # 0x1cbd8
movl 0x1020(%rbx), %esi
leaq 0x10d0(%rbx), %rdi
callq 0x4446
testq %rax, %rax
je 0x4b6f
movl 0x1024(%rbx), %ecx
movl 0x1028(%rbx), %edx
cmpl $0x2, %edx
je 0x4b65
cmpl $0x1, %edx
je 0x4b60
testl %edx, %edx
je 0x4b6c
movq 0x748f(%rip), %rdi      # 0xbfc0
leaq 0x3505(%rip), %rsi      # 0x803d
callq 0x31e0
movl 0x1028(%rbx), %esi
movq %rax, %rdi
callq 0x33b0
leaq 0x360c(%rip), %rsi      # 0x815e
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31e0
addl %ecx, 0x10(%rax)
jmp 0x4b6f
movq 0x8(%rax), %rdx
addl 0x1c(%rdx), %ecx
movl %ecx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Rdwr(File::FileFlags)
void FileManager::Rdwr(enum File::FileFlags mode) 
{
    File* pFile;
    User& u = globalUser;

    /* ����Read()/Write()��ϵͳ���ò���fd��ȡ�����ļ����ƿ��ṹ */
    pFile = u.u_ofiles.GetF(u.u_arg[0]);	/* fd */
    if (NULL == pFile) 
    {
        /* �����ڸô����ļ���GetF�Ѿ����ù������룬�������ﲻ��Ҫ�������� */
        /*	u.u_error = User::EBADF;	*/
        return;
    }

    /* ��д��ģʽ����ȷ */
    if ((pFile->f_flag & mode) == 0) 
    {
        u.u_error = User::myEACCES;
        return;
    }

    u.u_IOParam.m_Base = (unsigned char*)u.u_arg[1];     /* Ŀ�껺������ַ */
    u.u_IOParam.m_Count = u.u_arg[2];		/* Ҫ����/д���ֽ��� */

    u.u_IOParam.m_Offset = pFile->f_offset;   /* �����ļ���ʼ��λ�� */
    if (File::FREAD == mode) 
    {
        pFile->f_inode->ReadI();
    }
    else 
    {
        pFile->f_inode->WriteI();
    }

    /* ���ݶ�д�������ƶ��ļ���дƫ��ָ�� */
    pFile->f_offset += (u.u_arg[2] - u.u_IOParam.m_Count);

    /* ����ʵ�ʶ�д���ֽ������޸Ĵ���ϵͳ���÷���ֵ�ĺ���ջ��Ԫ */
    u.u_ar0[User::EAX] = u.u_arg[2] - u.u_IOParam.m_Count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
leaq 0x1803e(%rip), %r15     # 0x1cbd8
movl 0x1020(%r15), %esi
leaq 0x10d0(%r15), %rdi
callq 0x4446
testq %rax, %rax
je 0x4c23
movq %rax, %rbx
testl %r14d, (%rax)
je 0x4bf1
movslq 0x1024(%r15), %rax
movq %rax, 0x13f0(%r15)
movl 0x1028(%r15), %eax
movl %eax, 0x13fc(%r15)
movl 0x10(%rbx), %eax
movl %eax, 0x13f8(%r15)
movq 0x8(%rbx), %rdi
cmpl $0x1, %r14d
jne 0x4bfe
callq 0x54f6
jmp 0x4c03
movl $0xd, 0x10c8(%r15)
jmp 0x4c23
callq 0x57f6
movl 0x1028(%r15), %eax
movl 0x13fc(%r15), %ecx
subl %ecx, %eax
addl %eax, 0x10(%rbx)
movl 0x1028(%r15), %eax
subl %ecx, %eax
movl %eax, 0x20(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Ls()
void FileManager::Ls() 
{
    User& u = globalUser;
    BufferManager& bufferManager = globalBufferManager;

    Inode* pINode = u.u_cdir;
    Buf* pBuffer = NULL;
    u.u_IOParam.m_Offset = 0;
    u.u_IOParam.m_Count = pINode->i_size / sizeof(DirectoryEntry);

    int lsCnt = 0;

    while (u.u_IOParam.m_Count) 
    {
        if (0 == u.u_IOParam.m_Offset % Inode::BLOCK_SIZE) 
        {
            if (pBuffer) 
            {
                bufferManager.Brelse(pBuffer);
            }
            int phyBlkno = pINode->Bmap(u.u_IOParam.m_Offset / Inode::BLOCK_SIZE);
            pBuffer = bufferManager.Bread(phyBlkno);
        }
        memcpy(&u.u_dent, pBuffer->b_addr + (u.u_IOParam.m_Offset % Inode::BLOCK_SIZE), sizeof(u.u_dent));
        u.u_IOParam.m_Offset += sizeof(DirectoryEntry);
        u.u_IOParam.m_Count--;

        if (0 == u.u_dent.m_ino)
            continue;
        u.ls += u.u_dent.name;
        u.ls += " ";
        lsCnt++;
        if (lsCnt % 7 == 0)
            u.ls += "\n";
    }

    if (pBuffer) 
    {
        bufferManager.Brelse(pBuffer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x17f82(%rip), %r13     # 0x1cbd8
movq 0x1058(%r13), %rbx
andl $0x0, 0x13f8(%r13)
movl 0x1c(%rbx), %esi
sarl $0x5, %esi
movl %esi, 0x13fc(%r13)
movq $0x0, -0x30(%rbp)
movl $0x200, %r14d           # imm = 0x200
leaq 0x75d9(%rip), %r15      # 0xc260
leaq 0x1408(%r13), %rax
movq %rax, -0x48(%rbp)
leaq 0x106c(%r13), %rax
movq %rax, -0x40(%rbp)
movl $0x1408, %eax           # imm = 0x1408
addq 0x731f(%rip), %rax      # 0xbfc8
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
testl %esi, %esi
je 0x4da7
movl 0x13f8(%r13), %ecx
testw $0x1ff, %cx             # imm = 0x1FF
jne 0x4d08
testq %r12, %r12
je 0x4cdd
movq %r15, %rdi
movq %r12, %rsi
callq 0x3a16
movl 0x13f8(%r13), %ecx
movl %ecx, %eax
cltd
idivl %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x5608
movq %r15, %rdi
movl %eax, %esi
callq 0x3a46
movq %rax, %r12
movl 0x13f8(%r13), %ecx
movl 0x13fc(%r13), %esi
movq 0x20(%r12), %rdi
movl %ecx, %eax
cltd
idivl %r14d
movslq %edx, %rax
movups (%rdi,%rax), %xmm0
movups 0x10(%rdi,%rax), %xmm1
movups %xmm0, 0x1068(%r13)
movups %xmm1, 0x1078(%r13)
addl $0x20, %ecx
movl %ecx, 0x13f8(%r13)
decl %esi
movl %esi, 0x13fc(%r13)
cmpl $0x0, 0x1068(%r13)
je 0x4cb0
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x33e0
movq %r15, %rdi
leaq 0x33ce(%rip), %rsi      # 0x8138
callq 0x33e0
movq -0x30(%rbp), %rax
incl %eax
movq %rax, -0x30(%rbp)
xorl %edx, %edx
pushq $0x7
popq %rcx
divl %ecx
testl %edx, %edx
jne 0x4d94
movq -0x38(%rbp), %rdi
leaq 0x3339(%rip), %rsi      # 0x80c8
callq 0x33e0
movl 0x13fc(%r13), %esi
leaq 0x74be(%rip), %r15      # 0xc260
jmp 0x4cb0
testq %r12, %r12
je 0x4dc9
leaq 0x74ad(%rip), %rdi      # 0xc260
movq %r12, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a16
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::ChDir()
void FileManager::ChDir() 
{
    Inode* pINode;
    User& u = globalUser;

    pINode = this->NameI(FileManager::OPEN);
    if (NULL == pINode) {
        return;
    }

    /* ���������ļ�����Ŀ¼�ļ� */
    if ((pINode->i_mode & Inode::IFMT) != Inode::IFDIR) {
        u.u_error = User::myENOTDIR;
        this->m_InodeTable->IPut(pINode);
        return;
    }

    u.u_cdir = pINode;
    /* ·�����ǴӸ�Ŀ¼'/'��ʼ����������u.u_curdir�������ϵ�ǰ·������ */
    if (u.u_dirp[0] != '/') {
        u.u_curdir += u.u_dirp;
    }
    else {
        /* �����ǴӸ�Ŀ¼'/'��ʼ����ȡ��ԭ�й���Ŀ¼ */
        u.u_curdir = u.u_dirp;
    }
    if (u.u_curdir.back() != '/')
        u.u_curdir.push_back('/');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x4514
testq %rax, %rax
je 0x4e7b
movl $0x6000, %ecx           # imm = 0x6000
andl 0x4(%rax), %ecx
cmpl $0x4000, %ecx           # imm = 0x4000
jne 0x4e30
leaq 0x17dd0(%rip), %rbx     # 0x1cbd8
movq %rax, 0x1058(%rbx)
movq 0x1038(%rbx), %rax
cmpb $0x2f, (%rax)
jne 0x4e53
leaq 0x10a8(%rbx), %rdi
leaq 0x1038(%rbx), %rsi
callq 0x3120
jmp 0x4e66
leaq 0x17da1(%rip), %rcx     # 0x1cbd8
movl $0x14, 0x10c8(%rcx)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5d14
leaq 0x10a8(%rbx), %rdi
leaq 0x1038(%rbx), %rsi
callq 0x3410
movq 0x10a8(%rbx), %rax
movq 0x10b0(%rbx), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
jne 0x4e82
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x10a8, %edi           # imm = 0x10A8
addq 0x713a(%rip), %rdi      # 0xbfc8
pushq $0x2f
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31a0