LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x80(%rax), %rcx
movq (%rax,%rcx,8), %rcx
movq %rcx, -0x10(%rbp)
movl 0x80(%rax), %ecx
addl $0xd, %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
xorq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
shlq $0x10, %rdx
xorq %rdx, %rcx
movq -0x20(%rbp), %rdx
shlq $0xf, %rdx
xorq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movl 0x80(%rax), %ecx
addl $0x9, %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
shrq $0xb, %rcx
xorq -0x20(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorq -0x20(%rbp), %rcx
movslq 0x80(%rax), %rdx
movq %rcx, (%rax,%rdx,8)
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
shlq $0x5, %rdx
movabsq $0xda442d20, %rsi       # imm = 0xDA442D20
andq %rsi, %rdx
xorq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movl 0x80(%rax), %ecx
addl $0xf, %ecx
andl $0xf, %ecx
movl %ecx, 0x80(%rax)
movslq 0x80(%rax), %rcx
movq (%rax,%rcx,8), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdx
xorq -0x18(%rbp), %rdx
xorq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
xorq %rcx, %rdx
movq -0x18(%rbp), %rcx
shlq $0x12, %rcx
xorq %rcx, %rdx
movq -0x20(%rbp), %rcx
shlq $0x1c, %rcx
xorq %rcx, %rdx
movslq 0x80(%rax), %rcx
movq %rdx, (%rax,%rcx,8)
movslq 0x80(%rax), %rcx
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: Leeingnyo[P]newPuyoC/./puyo.h
// Function: BiPuyo::RotateCCW()
void RotateCCW() {
        // Rotate CounterClockWise
        switch (direction) {
            case Direction::UP:    { direction = Direction::LEFT; } break;
            case Direction::RIGHT: { direction = Direction::UP; } break;
            case Direction::DOWN:  { direction = Direction::RIGHT; } break;
            case Direction::LEFT:  { direction = Direction::DOWN; } break;
            default: direction = Direction::UP; break;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x4(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0xb825
movq -0x10(%rbp), %rax
leaq 0xe8dc(%rip), %rcx      # 0x1a0c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl $0x3, 0x4(%rax)
jmp 0xb830
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0xb830
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0xb830
movq -0x18(%rbp), %rax
movl $0x2, 0x4(%rax)
jmp 0xb830
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0xa0(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xa0(%rcx)
cmpl 0x9c(%rcx), %eax
jge 0xbadf
jmp 0xbb31
movq -0x18(%rbp), %rcx
movl 0xa8(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xa8(%rcx)
cmpl 0xa4(%rcx), %eax
jge 0xbafe
jmp 0xbb31
movq -0x18(%rbp), %rdi
movl $0x0, 0xa8(%rdi)
callq 0xc9a0
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xbb31
movq -0x18(%rbp), %rax
movl $0x2, 0x68(%rax)
movl $0x0, 0xa0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x9(%rbp)
movl $0xc, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0xca99
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0xca89
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
imulq $0x6, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
callq 0xb7a0
testb $0x1, %al
jne 0xc9fb
jmp 0xca79
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x6, %rax, %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
callq 0xb7a0
testb $0x1, %al
jne 0xca79
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x6, %rcx, %rcx
movq %rax, %rdx
addq %rcx, %rdx
movslq -0x14(%rbp), %rsi
movslq -0x10(%rbp), %rcx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb (%rdx,%rsi), %dl
movb %dl, (%rax,%rcx)
leaq -0x15(%rbp), %rdi
callq 0xcab0
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb -0x15(%rbp), %dl
movb %dl, (%rax,%rcx)
movb $0x1, -0x9(%rbp)
jmp 0xca7b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc9d0
jmp 0xca8b
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc9bf
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x2750, %rsp           # imm = 0x2750
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2740(%rbp)
movl $0x0, 0x80(%rax)
leaq -0x1390(%rbp), %rdi
movq %rdi, -0x2738(%rbp)
callq 0x13010
movq -0x2738(%rbp), %rdi
callq 0x130b0
movl %eax, -0x272c(%rbp)
jmp 0x12f5b
movl -0x272c(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x2718(%rbp), %rdi
callq 0x130d0
jmp 0x12f73
movl $0x0, -0x2728(%rbp)
cmpl $0x10, -0x2728(%rbp)
jge 0x12fe5
leaq -0x2718(%rbp), %rdi
callq 0x13100
movq %rax, -0x2748(%rbp)
jmp 0x12f9b
movq -0x2740(%rbp), %rax
movq -0x2748(%rbp), %rdx
movslq -0x2728(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2728(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2728(%rbp)
jmp 0x12f7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2720(%rbp)
movl %eax, -0x2724(%rbp)
leaq -0x1390(%rbp), %rdi
callq 0x131c0
jmp 0x12ffa
leaq -0x1390(%rbp), %rdi
callq 0x131c0
addq $0x2750, %rsp           # imm = 0x2750
popq %rbp
retq
movq -0x2720(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rcx
addq $0x4e, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xcab0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x1, %rax
cmpq %rcx, %rax
movq %rax, -0x10(%rbp)
jne 0x14263
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x14350
movq -0x20(%rbp), %rax
movl $0x23, 0x7c(%rax)
movl $0x5, 0x84(%rax)
movl $0x3, 0x8c(%rax)
movl $0x1, 0x94(%rax)
movl $0xf, 0x9c(%rax)
movl $0x2, 0xa4(%rax)
movl $0x1e, 0xac(%rax)
movl $0x0, 0x6c(%rax)
movl $0x0, 0x70(%rax)
movl $0x0, 0x74(%rax)
movl $0x0, 0x78(%rax)
movl $0x0, 0x80(%rax)
movl $0x0, 0x88(%rax)
movl $0x0, 0x90(%rax)
movl $0x0, 0x98(%rax)
movl $0x0, 0xa0(%rax)
movl $0x0, 0xa8(%rax)
movl $0x0, 0xb0(%rax)
movl $0x0, 0x68(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x30(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x3c96
cmpl $0x0, -0xc(%rbp)
je 0x3bb6
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movslq -0xc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rcx
addq $-0x38, %rcx
addq $0x8, %rax
movslq -0xc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x3bec
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq %rax, %rcx
addq $0x8, %rcx
movslq -0xc(%rbp), %rsi
imulq $0x38, %rsi, %rsi
addq %rsi, %rcx
movq %rdx, 0x8(%rcx)
movq %rax, %rcx
addq $0x8, %rcx
movslq -0xc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rcx
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cmpl $0x64, %eax
jge 0x3c26
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movslq -0xc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rcx
addq $0x38, %rcx
addq $0x8, %rax
movslq -0xc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
jmp 0x3c5c
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq %rax, %rcx
addq $0x8, %rcx
movslq -0xc(%rbp), %rsi
imulq $0x38, %rsi, %rsi
addq %rsi, %rcx
movq %rdx, 0x10(%rcx)
movq %rax, %rcx
addq $0x8, %rcx
movslq -0xc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rcx
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x15e8, %rcx           # imm = 0x15E8
movslq -0xc(%rbp), %rdx
shlq $0x9, %rdx
addq %rdx, %rcx
addq $0x8, %rax
movslq -0xc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b77
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0xddf0, %rdi           # imm = 0xDDF0
leaq -0x14(%rbp), %rsi
callq 0x43d0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0xddf0, %rdi           # imm = 0xDDF0
callq 0x4400
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x43a0
testb $0x1, %al
jne 0x3cf2
jmp 0x3d27
movq -0x38(%rbp), %rdi
addq $0xddf0, %rdi           # imm = 0xDDF0
leaq -0x14(%rbp), %rsi
callq 0x4430
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x3e20
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e10
movq -0x38(%rbp), %rcx
movq (%rcx), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jne 0x3d6e
movq 0x10282(%rip), %rdi     # 0x13fc8
leaq 0xa2bb(%rip), %rsi      # 0xe008
callq 0x32e0
movq %rax, %rdi
movq 0x10254(%rip), %rsi     # 0x13fb0
callq 0x3330
movq $0x0, -0x8(%rbp)
jmp 0x3e10
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3e20
movq -0x38(%rbp), %rdi
addq $0xddf0, %rdi           # imm = 0xDDF0
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
callq 0x4460
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x3dcd
movq -0x38(%rbp), %rax
movq 0xdde8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x6100
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff7b, %ecx       # imm = 0xFFFFFF7B
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0xddf0, %rdi           # imm = 0xDDF0
leaq -0x14(%rbp), %rsi
callq 0x4430
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3e39
jmp 0x3e79
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3ed1
jmp 0x3f09
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x10(%rbp), %rdx
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rdx, 0x10(%rcx)
movq -0x10(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
callq 0x3ca0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x84, %eax
cmpl $0x0, %eax
je 0x3f4d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f8a
movq -0x28(%rbp), %rax
movq 0xdde8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x6160
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %edx
andl $0xffffff7f, %edx       # imm = 0xFFFFFF7F
movl %edx, (%rcx)
movq 0xdde8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x6100
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
callq 0x3e80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3b00
movl $0x0, -0x44(%rbp)
cmpl $0x64, -0x44(%rbp)
jge 0x4066
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movslq -0x44(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
leaq -0x40(%rbp), %rsi
movl $0x38, %edx
callq 0x3260
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4034
movq -0x50(%rbp), %rdi
callq 0x3b60
leaq -0x40(%rbp), %rdi
callq 0x3b50
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x4190
movq -0x20(%rbp), %rax
addq $0x8, %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4183
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %edx
andl $0xffffff7f, %edx       # imm = 0xFFFFFF7F
movl %edx, (%rcx)
movq 0xdde8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x6100
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x4, %ecx
movl %ecx, (%rax)
jmp 0x4185
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4113
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xe26d(%rip), %rdi      # 0x14328
leaq 0x7f64(%rip), %rsi      # 0xe026
callq 0x33a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x60f6
movq 0xe24a(%rip), %rsi      # 0x14328
leaq 0x7f45(%rip), %rdi      # 0xe02a
movb $0x0, %al
callq 0x3060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x33b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ljl0222[P]SecondFileSystem/File.cpp
// Function: File::File()
File::File()
{
	this->f_count = 0;
	this->f_flag = 0;
	this->f_offset = 0;
	this->f_inode = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: ljl0222[P]SecondFileSystem/File.cpp
// Function: OpenFiles::AllocFreeSlot()
int OpenFiles::AllocFreeSlot()
{
	int i;
	User& u = globalUser;

	for (i = 0; i < OpenFiles::NOFILES; i++)
	{
		/* ���̴����ļ������������ҵ�������򷵻�֮ */
		if (this->ProcessOpenFileTable[i] == NULL)
		{
			/* ���ú���ջ�ֳ��������е�EAX�Ĵ�����ֵ����ϵͳ���÷���ֵ */
			u.u_ar0[User::EAX] = i;
			return i;
		}
	}

	u.u_ar0[User::EAX] = -1;   /* Open1����Ҫһ����־���������ļ��ṹ����ʧ��ʱ�����Ի���ϵͳ��Դ*/
	u.u_error = User::myEMFILE;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1ea71(%rip), %rax     # 0x24cc8
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x6299
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x628c
movl -0x14(%rbp), %ecx
leaq 0x1ea47(%rip), %rax     # 0x24cc8
movl %ecx, 0x20(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x62bf
jmp 0x628e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6262
leaq 0x1ea28(%rip), %rax     # 0x24cc8
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
leaq 0x1ea1a(%rip), %rax     # 0x24cc8
movl $0x18, 0x10c8(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ljl0222[P]SecondFileSystem/File.cpp
// Function: OpenFiles::GetF(int)
File* OpenFiles::GetF(int fd)
{
	File* pFile;
	User& u = globalUser;

	/* ���������ļ���������ֵ�����˷�Χ */
	if (fd < 0 || fd >= OpenFiles::NOFILES)
	{
		u.u_error = User::myEBADF;
		return NULL;
	}

	pFile = this->ProcessOpenFileTable[fd];
	if (pFile == NULL)
	{
		u.u_error = User::myEBADF;
	}

	return pFile;	/* ��ʹpFile==NULLҲ���������ɵ���GetF�ĺ������жϷ���ֵ */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1e9de(%rip), %rax     # 0x24cc8
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x62fa
cmpl $0x64, -0x14(%rbp)
jl 0x6315
leaq 0x1e9c7(%rip), %rax     # 0x24cc8
movl $0x9, 0x10c8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x6345
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x633d
leaq 0x1e995(%rip), %rax     # 0x24cc8
movl $0x9, 0x10c8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1cb0d(%rip), %rcx     # 0x22ed8
movq %rcx, 0x8(%rax)
leaq 0x1bda2(%rip), %rcx     # 0x22178
movq %rcx, 0x18(%rax)
leaq 0x1cb0f(%rip), %rcx     # 0x22ef0
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x8ec0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movl 0x8(%rax), %ecx
addl $0xff, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Open()
void FileManager::Open() 
{
    User& u = globalUser;
    Inode* pINode;
    pINode = this->NameI(FileManager::OPEN); /* 0 = Open, not create */
    /* û���ҵ���Ӧ��Inode */
    if (NULL == pINode) {
        return;
    }
    this->Open1(pINode, u.u_arg[1], 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x1e88d(%rip), %rax     # 0x24cc8
movq %rax, -0x10(%rbp)
xorl %esi, %esi
callq 0x6480
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x6454
jmp 0x6470
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x1e865(%rip), %rax     # 0x24cc8
movl 0x1024(%rax), %edx
xorl %ecx, %ecx
callq 0x6940
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x1e363(%rip), %rax     # 0x24cc8
movq %rax, -0x20(%rbp)
movl $0x1, %eax
cmpl -0x18(%rbp), %eax
jne 0x697c
movq -0x10(%rbp), %rdi
callq 0x8700
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8bc0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x69a8
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d20
jmp 0x6a1d
movl -0x14(%rbp), %ecx
andl $0x3, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x1e301(%rip), %rax     # 0x24cc8
cmpl $0x0, 0x10c8(%rax)
jne 0x69d2
jmp 0x6a1d
leaq 0x1e2ef(%rip), %rax     # 0x24cc8
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
je 0x6a0c
movl -0x2c(%rbp), %esi
leaq 0x1e2d9(%rip), %rdi     # 0x24cc8
addq $0x10d0, %rdi           # imm = 0x10D0
xorl %eax, %eax
movl %eax, %edx
callq 0x6350
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d20
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x1e27d(%rip), %rax     # 0x24cc8
movq %rax, -0x18(%rbp)
leaq 0x1e272(%rip), %rax     # 0x24cc8
movl 0x1024(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, %esi
callq 0x6480
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x6ab7
leaq 0x1e24c(%rip), %rax     # 0x24cc8
cmpl $0x0, 0x10c8(%rax)
je 0x6a87
jmp 0x6adb
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6af0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x6aa1
jmp 0x6adb
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %ecx
movl %ecx, %edx
callq 0x6940
jmp 0x6adb
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x6940
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1e1ba(%rip), %rcx     # 0x24cc8
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
callq 0x7870
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x6b31
movq $0x0, -0x8(%rbp)
jmp 0x6b6c
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl $0x6, %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x20(%rbp), %rsi
callq 0x6b80
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1e129(%rip), %rax     # 0x24cc8
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
leaq 0x1e117(%rip), %rax     # 0x24cc8
movl %ecx, 0x1068(%rax)
leaq 0x1e10a(%rip), %rax     # 0x24cc8
movq 0x1088(%rax), %rcx
movq %rcx, 0x106c(%rax)
movq 0x1090(%rax), %rcx
movq %rcx, 0x1074(%rax)
movq 0x1098(%rax), %rcx
movq %rcx, 0x107c(%rax)
movl 0x10a0(%rax), %ecx
movl %ecx, 0x1084(%rax)
leaq 0x1e0cd(%rip), %rax     # 0x24cc8
movl $0x20, 0x13fc(%rax)
leaq 0x1e0bc(%rip), %rax     # 0x24cc8
movq %rax, %rcx
addq $0x1068, %rcx           # imm = 0x1068
movq %rcx, 0x13f0(%rax)
leaq 0x1e0a4(%rip), %rax     # 0x24cc8
movq 0x1060(%rax), %rdi
callq 0x8310
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x1e089(%rip), %rax     # 0x24cc8
movq 0x1060(%rax), %rsi
callq 0x8d20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1e04d(%rip), %rax     # 0x24cc8
movq %rax, -0x10(%rbp)
leaq 0x1e042(%rip), %rax     # 0x24cc8
movl 0x1020(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
leaq 0x1e02f(%rip), %rdi     # 0x24cc8
addq $0x10d0, %rdi           # imm = 0x10D0
callq 0x62d0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x6cb3
jmp 0x6cde
movl -0x14(%rbp), %esi
leaq 0x1e00b(%rip), %rdi     # 0x24cc8
addq $0x10d0, %rdi           # imm = 0x10D0
xorl %eax, %eax
movl %eax, %edx
callq 0x6350
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x8cd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x1dfbd(%rip), %rax     # 0x24cc8
movq %rax, -0x20(%rbp)
movl $0x2, %esi
callq 0x6480
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x6d2a
jmp 0x6def
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x1df8f(%rip), %rax     # 0x24cc8
movl 0x1068(%rax), %esi
callq 0x8ec0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x6d55
jmp 0x6def
leaq 0x1df6c(%rip), %rax     # 0x24cc8
movl 0x13f8(%rax), %ecx
subl $0x20, %ecx
leaq 0x1df5c(%rip), %rax     # 0x24cc8
movl %ecx, 0x13f8(%rax)
leaq 0x1df4f(%rip), %rax     # 0x24cc8
movq %rax, %rcx
addq $0x1068, %rcx           # imm = 0x1068
movq %rcx, 0x13f0(%rax)
leaq 0x1df37(%rip), %rax     # 0x24cc8
movl $0x20, 0x13fc(%rax)
leaq 0x1df26(%rip), %rax     # 0x24cc8
movl $0x0, 0x1068(%rax)
movq -0x18(%rbp), %rdi
callq 0x8310
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0xc(%rcx)
movq -0x10(%rbp), %rcx
movl (%rcx), %edx
orl $0x2, %edx
movl %edx, (%rcx)
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x8d20
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1deb5(%rip), %rax     # 0x24cc8
movq %rax, -0x18(%rbp)
leaq 0x1deaa(%rip), %rax     # 0x24cc8
movl 0x1020(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
leaq 0x1de97(%rip), %rdi     # 0x24cc8
addq $0x10d0, %rdi           # imm = 0x10D0
callq 0x62d0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x6e4e
jmp 0x6eea
leaq 0x1de73(%rip), %rax     # 0x24cc8
movl 0x1024(%rax), %ecx
movl %ecx, -0x20(%rbp)
movl 0x1028(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x6e81
jmp 0x6e6d
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x6e8d
jmp 0x6e77
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x6e9c
jmp 0x6eb3
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x6eea
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x6eea
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x1c(%rax), %ecx
addl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x6eea
movq 0xd10e(%rip), %rdi      # 0x13fc8
leaq 0x7180(%rip), %rsi      # 0xe041
callq 0x32e0
movq %rax, %rdi
leaq 0x1ddf8(%rip), %rax     # 0x24cc8
movl 0x1028(%rax), %esi
callq 0x3570
movq %rax, %rdi
leaq 0x72b1(%rip), %rsi      # 0xe196
callq 0x32e0
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x1dda2(%rip), %rax     # 0x24cc8
movq %rax, -0x20(%rbp)
leaq 0x1dd97(%rip), %rax     # 0x24cc8
movl 0x1020(%rax), %esi
leaq 0x1dd8a(%rip), %rdi     # 0x24cc8
addq $0x10d0, %rdi           # imm = 0x10D0
callq 0x62d0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x6f5b
jmp 0x7037
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
jne 0x6f7f
leaq 0x1dd58(%rip), %rax     # 0x24cc8
movl $0xd, 0x10c8(%rax)
jmp 0x7037
leaq 0x1dd42(%rip), %rax     # 0x24cc8
movslq 0x1024(%rax), %rcx
leaq 0x1dd34(%rip), %rax     # 0x24cc8
movq %rcx, 0x13f0(%rax)
leaq 0x1dd26(%rip), %rax     # 0x24cc8
movl 0x1028(%rax), %ecx
leaq 0x1dd19(%rip), %rax     # 0x24cc8
movl %ecx, 0x13fc(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x1dd05(%rip), %rax     # 0x24cc8
movl %ecx, 0x13f8(%rax)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jne 0x6fe2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7e20
jmp 0x6fef
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8310
leaq 0x1dcd2(%rip), %rax     # 0x24cc8
movl 0x1028(%rax), %ecx
leaq 0x1dcc5(%rip), %rax     # 0x24cc8
subl 0x13fc(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
leaq 0x1dcae(%rip), %rax     # 0x24cc8
movl 0x1028(%rax), %ecx
leaq 0x1dca1(%rip), %rax     # 0x24cc8
subl 0x13fc(%rax), %ecx
leaq 0x1dc94(%rip), %rax     # 0x24cc8
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x1da1d(%rip), %rax     # 0x24cc8
movq %rax, -0x18(%rbp)
xorl %esi, %esi
callq 0x6480
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x72c7
jmp 0x73a1
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x6000, %eax           # imm = 0x6000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x7301
movq -0x20(%rbp), %rax
leaq 0x1d9e3(%rip), %rcx     # 0x24cc8
movl $0x14, 0x10c8(%rcx)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d20
jmp 0x73a1
movq -0x10(%rbp), %rcx
leaq 0x1d9bc(%rip), %rax     # 0x24cc8
movq %rcx, 0x1058(%rax)
leaq 0x1d9ae(%rip), %rdi     # 0x24cc8
addq $0x1038, %rdi           # imm = 0x1038
xorl %eax, %eax
movl %eax, %esi
callq 0x3610
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x7351
leaq 0x1d98f(%rip), %rsi     # 0x24cc8
movq %rsi, %rdi
addq $0x10a8, %rdi           # imm = 0x10A8
addq $0x1038, %rsi           # imm = 0x1038
callq 0x3420
jmp 0x736e
leaq 0x1d970(%rip), %rsi     # 0x24cc8
movq %rsi, %rdi
addq $0x10a8, %rdi           # imm = 0x10A8
addq $0x1038, %rsi           # imm = 0x1038
callq 0x3040
leaq 0x1d953(%rip), %rdi     # 0x24cc8
addq $0x10a8, %rdi           # imm = 0x10A8
callq 0x3220
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x73a1
leaq 0x1d938(%rip), %rdi     # 0x24cc8
addq $0x10a8, %rdi           # imm = 0x10A8
movl $0x2f, %esi
callq 0x3280
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ljl0222[P]SecondFileSystem/FileSystem.cpp
// Function: FileSystem::FileSystem()
FileSystem::FileSystem()
{
	m_DeviceManager = &globalDeviceManager;
	m_SuperBlock = &globalSuperBlock;
	m_BufferManager = &globalBufferManager;

	if (!m_DeviceManager->Exists())
		FormatFileSystem();
	else
		LoadSuperBlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xcf5d(%rip), %rcx      # 0x14348
movq %rcx, 0x10(%rax)
leaq 0x1b6e2(%rip), %rcx     # 0x22ad8
movq %rcx, 0x8(%rax)
leaq 0xcf4f(%rip), %rcx      # 0x14350
movq %rcx, (%rax)
movq 0x10(%rax), %rdi
callq 0x6080
testb $0x1, %al
jne 0x741c
movq -0x10(%rbp), %rdi
callq 0x7430
jmp 0x7425
movq -0x10(%rbp), %rdi
callq 0x7730
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ljl0222[P]SecondFileSystem/FileSystem.cpp
// Function: FileSystem::Update()
void FileSystem::Update()
{
	SuperBlock* sb;
	Buf* pBuf;

	m_SuperBlock->s_fmod = 0;
	m_SuperBlock->s_time = (int)time(0);

	for (int cnt = 0; cnt < 2; cnt++) {
		int* p = (int*)m_SuperBlock + cnt * 128;
		pBuf = this->m_BufferManager->GetBlk(0 + cnt);
		memcpy(pBuf->b_addr, p, 512);
		m_BufferManager->Bwrite(pBuf);
	}

	globalINodeTable.UpdateInodeTable();
	m_BufferManager->Bflush();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rax
movl $0x0, 0x338(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x32c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x340(%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x7848
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x1c(%rbp), %edx
shll $0x7, %edx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
addl $0x0, %esi
callq 0x3ca0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x3260
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3fa0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x77e3
leaq 0x1b6a1(%rip), %rdi     # 0x22ef0
callq 0x90c0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x40f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ljl0222[P]SecondFileSystem/FileSystem.cpp
// Function: FileSystem::IFree(int)
void FileSystem::IFree(int number)
{
	/*
	 * ����������ֱ�ӹ����Ŀ�������Inode����100����
	 * ͬ�����ͷŵ�����Inodeɢ���ڴ���Inode���С�
	 */
	if (m_SuperBlock->s_ninode >= 100)
	{
		return;
	}

	m_SuperBlock->s_inode[m_SuperBlock->s_ninode++] = number;

	/* ����SuperBlock���޸ı�־ */
	m_SuperBlock->s_fmod = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
cmpl $0x64, 0x19c(%rax)
jl 0x7aa2
jmp 0x7add
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x8(%rax), %rcx
movq 0x8(%rax), %rdi
movl 0x19c(%rdi), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, 0x19c(%rdi)
movslq %edx, %rdx
movl %esi, 0x1a0(%rcx,%rdx,4)
movq 0x8(%rax), %rax
movl $0x1, 0x338(%rax)
popq %rbp
retq
nop