LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x192aa(%rip), %r14     # 0x1dbd8
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 0x5886
movq 0x10(%rbx), %rdi
movq 0x1060(%r14), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5dfa
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19236(%rip), %rdi     # 0x1dbd8
movl 0x1020(%rdi), %r14d
addq $0x10d0, %rdi           # imm = 0x10D0
movl %r14d, %esi
callq 0x43ec
testq %rax, %rax
je 0x49ec
movq %rax, %r15
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x8604(%rip), %rdi      # 0xcfd0
movl %r14d, %esi
xorl %edx, %edx
callq 0x4418
movq 0x18(%rbx), %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5dd4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x2, %esi
callq 0x44bc
testq %rax, %rax
je 0x4a9d
movq %rax, %r14
movq 0x10(%rbx), %rdi
leaq 0x191b1(%rip), %r12     # 0x1dbd8
movl 0x1068(%r12), %esi
callq 0x5ee2
testq %rax, %rax
je 0x4a9d
movq %rax, %r15
addl $-0x20, 0x13f8(%r12)
leaq 0x1068(%r12), %rax
movq %rax, 0x13f0(%r12)
movl $0x20, 0x13fc(%r12)
movl $0x0, 0x1068(%r12)
movq %r14, %rdi
callq 0x5886
decl 0xc(%r15)
orb $0x2, (%r15)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x5dfa
movq 0x10(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5dfa
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
leaq 0x19124(%rip), %r14     # 0x1dbd8
movl 0x1020(%r14), %esi
leaq 0x10d0(%r14), %rdi
callq 0x43ec
testq %rax, %rax
je 0x4b39
movl 0x1024(%r14), %ecx
movl 0x1028(%r14), %edx
cmpl $0x2, %edx
je 0x4b2f
cmpl $0x1, %edx
je 0x4b2a
testl %edx, %edx
je 0x4b36
movq 0x84d9(%rip), %rbx      # 0xcfc8
leaq 0x4546(%rip), %rsi      # 0x903c
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3260
movl 0x1028(%r14), %esi
movq %rbx, %rdi
callq 0x33c0
leaq 0x4645(%rip), %rsi      # 0x915e
movl $0xc, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3260
addl %ecx, 0x10(%rax)
jmp 0x4b39
movq 0x8(%rax), %rdx
addl 0x1c(%rdx), %ecx
movl %ecx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19076(%rip), %r15     # 0x1dbd8
movl 0x1020(%r15), %esi
leaq 0x10d0(%r15), %rdi
callq 0x43ec
testq %rax, %rax
je 0x4beb
movq %rax, %rbx
testl %r14d, (%rax)
je 0x4bb9
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 0x4bc6
callq 0x554e
jmp 0x4bcb
movl $0xd, 0x10c8(%r15)
jmp 0x4beb
callq 0x5886
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_O1/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 0x18fba(%rip), %r15     # 0x1dbd8
movq 0x1058(%r15), %rbx
movl $0x0, 0x13f8(%r15)
movl 0x1c(%rbx), %eax
sarl $0x5, %eax
movl %eax, 0x13fc(%r15)
xorl %r13d, %r13d
leaq 0x8619(%rip), %r14      # 0xd260
leaq 0x1408(%r15), %rax
movq %rax, -0x48(%rbp)
leaq 0x106c(%r15), %rax
movq %rax, -0x40(%rbp)
movl $0x1408, %eax           # imm = 0x1408
addq 0x8367(%rip), %rax      # 0xcfd0
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
cmpl $0x0, 0x13fc(%r15)
je 0x4d74
movzwl 0x13f8(%r15), %eax
testl $0x1ff, %eax            # imm = 0x1FF
jne 0x4cc7
testq %r12, %r12
je 0x4c9d
movq %r14, %rdi
movq %r12, %rsi
callq 0x3a9c
movl 0x13f8(%r15), %eax
leal 0x1ff(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
sarl $0x9, %esi
movq %rbx, %rdi
callq 0x5684
movq %r14, %rdi
movl %eax, %esi
callq 0x3af0
movq %rax, %r12
movq 0x20(%r12), %rax
movl 0x13f8(%r15), %ecx
leal 0x1ff(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
andl $0xfffffe00, %edx       # imm = 0xFFFFFE00
movl %ecx, %esi
subl %edx, %esi
movslq %esi, %rdx
movups (%rax,%rdx), %xmm0
movups 0x10(%rax,%rdx), %xmm1
movups %xmm0, 0x1068(%r15)
movups %xmm1, 0x1078(%r15)
addl $0x20, %ecx
movl %ecx, 0x13f8(%r15)
decl 0x13fc(%r15)
cmpl $0x0, 0x1068(%r15)
je 0x4c70
movq %r13, -0x38(%rbp)
movq -0x48(%rbp), %r13
movq %r13, %rdi
movq -0x40(%rbp), %rsi
callq 0x3410
movq %r13, %rdi
movq -0x38(%rbp), %r13
leaq 0x43f3(%rip), %rsi      # 0x9138
callq 0x3410
incl %r13d
imull $0xb6db6db7, %r13d, %eax # imm = 0xB6DB6DB7
cmpl $0x24924924, %eax       # imm = 0x24924924
ja 0x4c70
movq -0x30(%rbp), %rdi
leaq 0x435e(%rip), %rsi      # 0x90c8
callq 0x3410
jmp 0x4c70
testq %r12, %r12
je 0x4d96
leaq 0x84e0(%rip), %rdi      # 0xd260
movq %r12, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a9c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44bc
testq %rax, %rax
je 0x4e49
movl $0x6000, %ecx           # imm = 0x6000
andl 0x4(%rax), %ecx
cmpl $0x4000, %ecx           # imm = 0x4000
jne 0x4dfe
leaq 0x18e02(%rip), %rbx     # 0x1dbd8
movq %rax, 0x1058(%rbx)
movq 0x1038(%rbx), %rsi
cmpb $0x2f, (%rsi)
jne 0x4e21
leaq 0x10a8(%rbx), %rdi
leaq 0x1038(%rbx), %rsi
callq 0x3130
jmp 0x4e34
leaq 0x18dd3(%rip), %rcx     # 0x1dbd8
movl $0x14, 0x10c8(%rcx)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5dfa
movq 0x1040(%rbx), %rdx
leaq 0x10a8(%rbx), %rdi
callq 0x30c0
movq 0x10a8(%rbx), %rax
movq 0x10b0(%rbx), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
jne 0x4e50
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x10a8, %edi           # imm = 0x10A8
addq 0x8174(%rip), %rdi      # 0xcfd0
movl $0x2f, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31c0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x83d0(%rip), %rdi      # 0xd258
movq %rdi, 0x10(%rbx)
leaq 0x16b55(%rip), %rax     # 0x1b9e8
movq %rax, 0x8(%rbx)
leaq 0x83c2(%rip), %rax      # 0xd260
movq %rax, (%rbx)
callq 0x429a
testb %al, %al
je 0x4ec7
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4334
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4ed6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl $0x0, 0x338(%rax)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x31e0
movq 0x8(%rbx), %rcx
movl %eax, 0x340(%rcx)
xorl %r13d, %r13d
movq 0x8(%rbx), %r15
addq %r13, %r15
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x38f0
movq %rax, %r12
movq 0x20(%rax), %rdi
movl $0x200, %edx            # imm = 0x200
movq %r15, %rsi
callq 0x31b0
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x3b30
movl $0x200, %eax            # imm = 0x200
addq %rax, %r13
incl %r14d
cmpq %rax, %r13
je 0x515e
leaq 0x16c5a(%rip), %rdi     # 0x1be00
callq 0x6040
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c2c
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/FileSystem.cpp
// Function: FileSystem::Alloc()
Buf* FileSystem::Alloc()
{
	int blkno;	/* ���䵽�Ŀ��д��̿����� */
	Buf* pBuf;
	User& u = globalUser;

	/* ����������ջ������ȡ���д��̿����� */
	blkno = m_SuperBlock->s_free[--m_SuperBlock->s_nfree];

	/*
	 * ����ȡ���̿�����Ϊ�㣬����ʾ�ѷ��価���еĿ��д��̿顣
	 * ���߷��䵽�Ŀ��д��̿����Ų����������̿�������(��BadBlock()����)��
	 * ����ζ�ŷ������д��̿�����ʧ�ܡ�
	 */
	if (0 >= blkno)
	{
		m_SuperBlock->s_nfree = 0;
		u.u_error = User::myENOSPC;
		return NULL;
	}

	/*
	 * ջ�ѿգ��·��䵽���д��̿��м�¼����һ�����д��̿��ı���,
	 * ����һ�����д��̿��ı��Ŷ���SuperBlock�Ŀ��д��̿�������s_free[100]�С�
	 */
	if (m_SuperBlock->s_nfree <= 0)
	{
		/* �����ÿ��д��̿� */
		pBuf = this->m_BufferManager->Bread(blkno);

		/* �Ӹô��̿���0�ֽڿ�ʼ��¼����ռ��4(s_nfree)+400(s_free[100])���ֽ� */
		int* p = (int*)pBuf->b_addr;

		/* ���ȶ��������̿���s_nfree */
		m_SuperBlock->s_nfree = *p++;

		/* ��ȡ�����к���λ�õ����ݣ�д�뵽SuperBlock�����̿�������s_free[100]�� */
		memcpy(m_SuperBlock->s_free, p, sizeof(m_SuperBlock->s_free));

		/* ����ʹ�����ϣ��ͷ��Ա㱻��������ʹ�� */
		this->m_BufferManager->Brelse(pBuf);
	}

	/* ��ͨ�����³ɹ����䵽һ���д��̿� */
	pBuf = this->m_BufferManager->GetBlk(blkno);	/* Ϊ�ô��̿����뻺�� */
	if (pBuf) {
		this->m_BufferManager->ClrBuf(pBuf);	/* ���ջ����е����� */
	}
	m_SuperBlock->s_fmod = 1;	/* ����SuperBlock���޸ı�־ */

	return pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movslq 0x8(%rax), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x8(%rax)
movl 0x8(%rax,%rcx,4), %r14d
testl %r14d, %r14d
jle 0x542f
movq %rdi, %rbx
cmpl $0x1, %ecx
jg 0x5401
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x3af0
movq %rax, %r15
movq 0x20(%rax), %rsi
movl (%rsi), %eax
addq $0x4, %rsi
movq 0x8(%rbx), %rdi
movl %eax, 0x8(%rdi)
addq $0xc, %rdi
movl $0x190, %edx            # imm = 0x190
callq 0x31b0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x3a9c
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x38f0
movq %rax, %r14
testq %rax, %rax
je 0x541f
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3c16
movq 0x8(%rbx), %rax
movl $0x1, 0x338(%rax)
jmp 0x544a
movl $0x0, 0x8(%rax)
leaq 0x1879b(%rip), %rax     # 0x1dbd8
movl $0x1c, 0x10c8(%rax)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/FileSystem.cpp
// Function: FileSystem::Free(int)
void FileSystem::Free(int blkno)
{
	Buf* pBuf;
	User& u = globalUser;


	/* SuperBlock��ֱ�ӹ������д��̿��ŵ�ջ���� */
	if (m_SuperBlock->s_nfree >= 100)
	{
		/*
		 * ʹ�õ�ǰFree()������Ҫ�ͷŵĴ��̿飬����ǰһ��100������
		 * ���̿���������
		 */
		pBuf = this->m_BufferManager->GetBlk(blkno);	/* Ϊ��ǰ��Ҫ�ͷŵĴ��̿����仺�� */

		/* �Ӹô��̿���0�ֽڿ�ʼ��¼����ռ��4(s_nfree)+400(s_free[100])���ֽ� */
		int* p = (int*)pBuf->b_addr;

		/* ����д�������̿��������˵�һ��Ϊ99�飬����ÿ�鶼��100�� */
		*p++ = m_SuperBlock->s_nfree;
		/* ��SuperBlock�Ŀ����̿�������s_free[100]д�뻺���к���λ�� */
		memcpy(p, m_SuperBlock->s_free, sizeof(int) * 100);

		m_SuperBlock->s_nfree = 0;
		/* �����ſ����̿��������ġ���ǰ�ͷ��̿顱д�����̣���ʵ���˿����̿���¼�����̿��ŵ�Ŀ�� */
		this->m_BufferManager->Bwrite(pBuf);
	}
	m_SuperBlock->s_free[m_SuperBlock->s_nfree++] = blkno;	/* SuperBlock�м�¼�µ�ǰ�ͷ��̿��� */
	m_SuperBlock->s_fmod = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpl $0x64, 0x8(%rax)
jl 0x54b3
movq (%r14), %rdi
movl %ebx, %esi
callq 0x38f0
movq %rax, %r15
movq 0x20(%rax), %rdi
movq 0x8(%r14), %rsi
movl 0x8(%rsi), %eax
movl %eax, (%rdi)
addq $0x4, %rdi
addq $0xc, %rsi
movl $0x190, %edx            # imm = 0x190
callq 0x31b0
movq 0x8(%r14), %rax
movl $0x0, 0x8(%rax)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3b30
movq 0x8(%r14), %rax
movslq 0x8(%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rax)
movl %ebx, 0xc(%rax,%rcx,4)
movl $0x1, 0x338(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/INode.cpp
// Function: Inode::IUpdate(int)
void Inode::IUpdate(int time)
{
	Buf* pBuf;
	DiskInode dInode;
	FileSystem& filesys = globalFileSystem;
	BufferManager& bufMgr = globalBufferManager;

	/* ��IUPD��IACC��־֮һ�����ã�����Ҫ������ӦDiskInode
	 * Ŀ¼����������������;����Ŀ¼�ļ���IACC��IUPD��־ */
	if ((this->i_flag & (Inode::IUPD | Inode::IACC)) != 0)
	{
		/* ���ص�ע�ͣ��ڻ��������ҵ�������i�ڵ㣨this->i_number���Ļ�����
		 * ����һ�������Ļ����飬���δ����е�Bwrite()�ڽ�������д�ش��̺����ͷŸû����顣
		 * ���ô��Ÿ�DiskInode���ַ������뻺���� */
		pBuf = bufMgr.Bread(FileSystem::INODE_ZONE_START_SECTOR + this->i_number / FileSystem::INODE_NUMBER_PER_SECTOR);

		/* ���ڴ�Inode�����е���Ϣ���Ƶ�dInode�У�Ȼ����dInode���ǻ����оɵ�����Inode */
		dInode.d_mode = this->i_mode;
		dInode.d_nlink = this->i_nlink;
		dInode.d_uid = this->i_uid;
		dInode.d_gid = this->i_gid;
		dInode.d_size = this->i_size;
		for (int i = 0; i < 10; i++)
		{
			dInode.d_addr[i] = this->i_addr[i];
		}

		if (this->i_flag & Inode::IACC)
		{
			/* ������������ʱ�� */
			dInode.d_atime = time;
		}
		if (this->i_flag & Inode::IUPD)
		{
			/* ������������ʱ�� */
			dInode.d_mtime = time;
		}

		/* ��pָ�򻺴����о�����Inode��ƫ��λ�� */
		unsigned char* p = pBuf->b_addr + (this->i_number % FileSystem::INODE_NUMBER_PER_SECTOR) * sizeof(DiskInode);
		DiskInode* pNode = &dInode;

		/* ��dInode�е������ݸ��ǻ����еľ�����Inode */
		memcpy(p, pNode, sizeof(DiskInode));

		/* ������д�������̣��ﵽ���¾�����Inode��Ŀ�� */
		bufMgr.Bwrite(pBuf);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
testb $0x6, (%rdi)
je 0x5ac0
movl %esi, %r14d
movq %rdi, %r15
movl 0x14(%rdi), %eax
leal 0x7(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
sarl $0x3, %esi
addl $0x2, %esi
leaq 0x7853(%rip), %rbx      # 0xd260
movq %rbx, %rdi
callq 0x3af0
movl 0x4(%r15), %edx
movl 0xc(%r15), %esi
movq 0x18(%r15), %rdi
movups 0x30(%r15), %xmm0
movaps %xmm0, -0x30(%rbp)
movq 0x40(%r15), %rcx
movq %rcx, -0x20(%rbp)
movups 0x20(%r15), %xmm0
movaps %xmm0, -0x40(%rbp)
movl (%r15), %ecx
movl 0x14(%r15), %r9d
movl %ecx, %r8d
shll $0x1d, %r8d
sarl $0x1f, %r8d
andl %r14d, %r8d
shll $0x1e, %ecx
sarl $0x1f, %ecx
andl %r14d, %ecx
movq 0x20(%rax), %r10
leal 0x7(%r9), %r11d
testl %r9d, %r9d
cmovnsl %r9d, %r11d
andl $-0x8, %r11d
subl %r11d, %r9d
movslq %r9d, %r9
shlq $0x6, %r9
movl %edx, (%r10,%r9)
movl %esi, 0x4(%r10,%r9)
movq %rdi, 0x8(%r10,%r9)
movq -0x20(%rbp), %rdx
movq %rdx, 0x30(%r10,%r9)
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movups %xmm1, 0x20(%r10,%r9)
movups %xmm0, 0x10(%r10,%r9)
movl %r8d, 0x38(%r10,%r9)
movl %ecx, 0x3c(%r10,%r9)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b30
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/INode.cpp
// Function: Inode::ICopy(Buf*, int)
void Inode::ICopy(Buf* bp, int inumber)
{
	DiskInode& dInode = *(DiskInode*)(bp->b_addr + (inumber % FileSystem::INODE_NUMBER_PER_SECTOR) * sizeof(DiskInode));

	/* ������Inode����dInode����Ϣ���Ƶ��ڴ�Inode�� */
	this->i_mode = dInode.d_mode;
	this->i_nlink = dInode.d_nlink;
	this->i_uid = dInode.d_uid;
	this->i_gid = dInode.d_gid;
	this->i_size = dInode.d_size;
	for (int i = 0; i < 10; i++)
	{
		this->i_addr[i] = dInode.d_addr[i];
	}

	memcpy(i_addr, dInode.d_addr, sizeof(i_addr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rsi), %rcx
leal 0x7(%rdx), %eax
testl %edx, %edx
cmovnsl %edx, %eax
andl $-0x8, %eax
subl %eax, %edx
movslq %edx, %rdx
shlq $0x6, %rdx
leaq (%rcx,%rdx), %rax
movl (%rcx,%rdx), %esi
movl %esi, 0x4(%rdi)
movl 0x4(%rcx,%rdx), %esi
movl %esi, 0xc(%rdi)
movzwl 0x8(%rcx,%rdx), %esi
movw %si, 0x18(%rdi)
movzwl 0xa(%rcx,%rdx), %esi
movw %si, 0x1a(%rdi)
movl 0xc(%rcx,%rdx), %ecx
movl %ecx, 0x1c(%rdi)
xorl %ecx, %ecx
movl 0x10(%rax,%rcx,4), %edx
movl %edx, 0x20(%rdi,%rcx,4)
incq %rcx
cmpq $0xa, %rcx
jne 0x5c5e
movq 0x30(%rax), %rcx
movq %rcx, 0x40(%rdi)
movups 0x10(%rax), %xmm0
movups 0x20(%rax), %xmm1
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/OpenFileManager.cpp
// Function: OpenFileTable::FAlloc()
File* OpenFileTable::FAlloc()
{
	int fd;
	User& u = globalUser;

	/* �ڽ��̴����ļ����������л�ȡһ�������� */
	fd = u.u_ofiles.AllocFreeSlot();

	if (fd < 0)	/* ����Ѱ�ҿ�����ʧ�� */
	{
		return NULL;
	}

	for (int i = 0; i < OpenFileTable::NFILE; i++)
	{
		/* f_count==0��ʾ�������� */
		if (this->m_File[i].f_count == 0)
		{
			/* ������������File�ṹ�Ĺ�����ϵ */
			u.u_ofiles.SetF(fd, &this->m_File[i]);
			/* ���Ӷ�file�ṹ�����ü��� */
			this->m_File[i].f_count++;
			/* �����ļ�����дλ�� */
			this->m_File[i].f_offset = 0;
			return (&this->m_File[i]);
		}
	}

	u.u_error = User::myENFILE;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x7286(%rip), %rdi      # 0xcfd0
callq 0x43aa
testl %eax, %eax
js 0x5dca
cmpl $0x0, 0x4(%rbx)
je 0x5d88
leaq 0x948(%rbx), %rcx
xorl %edx, %edx
cmpq $0x63, %rdx
je 0x5db0
leaq 0x18(%rbx), %rsi
incq %rdx
cmpl $0x0, 0x1c(%rbx)
movq %rsi, %rbx
jne 0x5d62
decq %rdx
cmpq $0x63, %rdx
setae %r14b
movq %rsi, %rbx
jmp 0x5d8b
xorl %r14d, %r14d
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x7239(%rip), %rdi      # 0xcfd0
movl %eax, %esi
movq %rbx, %rdx
callq 0x4418
incl 0x4(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rcx
jmp 0x5db4
setae %r14b
testb %r14b, %r14b
je 0x5dcc
leaq 0x17e18(%rip), %rax     # 0x1dbd8
movl $0x17, 0x10c8(%rax)
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/OpenFileManager.cpp
// Function: InodeTable::IPut(Inode*)
void InodeTable::IPut(Inode* pNode)
{
	/* ��ǰ����Ϊ���ø��ڴ�Inode��Ψһ���̣���׼���ͷŸ��ڴ�Inode */
	if (pNode->i_count == 1)
	{

		/* ���ļ��Ѿ�û��Ŀ¼·��ָ���� */
		if (pNode->i_nlink <= 0)
		{
			/* �ͷŸ��ļ�ռ�ݵ������̿� */
			pNode->ITrunc();
			pNode->i_mode = 0;
			/* �ͷŶ�Ӧ������Inode */
			this->m_FileSystem->IFree(pNode->i_number);
		}

		/* ��������Inode��Ϣ */
		pNode->IUpdate((int)time(NULL));

		/* �����ڴ�Inode�����б�־λ */
		pNode->i_flag = 0;
		/* �����ڴ�inode���еı�־֮һ����һ����i_count == 0 */
		pNode->i_number = -1;
	}

	/* �����ڴ�Inode�����ü��������ѵȴ����� */
	pNode->i_count--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x1, 0x8(%rsi)
jne 0x5e4f
cmpl $0x0, 0xc(%rbx)
jg 0x5e31
movq %rdi, %r14
movq %rbx, %rdi
callq 0x5acc
movl $0x0, 0x4(%rbx)
movq 0x1db0(%r14), %rdi
movl 0x14(%rbx), %esi
callq 0x536c
xorl %edi, %edi
callq 0x31e0
movq %rbx, %rdi
movl %eax, %esi
callq 0x59c6
movl $0x0, (%rbx)
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
decl 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/OpenFileManager.cpp
// Function: InodeTable::IGet(int)
Inode* InodeTable::IGet(int inumber)
{
	Inode* pInode;


	/* ����ָ���豸dev�б���Ϊinumber������Inode�Ƿ����ڴ濽�� */
	int index = this->IsLoaded(inumber);
	if (index >= 0)	/* �ҵ��ڴ濽�� */
	{
		pInode = m_Inode + index;

		/*
		 * ����ִ�е�������ʾ���ڴ�Inode���ٻ������ҵ���Ӧ�ڴ�Inode��
		 * ���������ü���������ILOCK��־������֮
		 */
		pInode->i_count++;
		return pInode;
	}
	else	/* û��Inode���ڴ濽����������һ�������ڴ�Inode */
	{
		pInode = this->GetFreeInode();
		/* ���ڴ�Inode����������������Inodeʧ�� */
		if (NULL == pInode)
		{
			cout << "INode Table ������" << endl;
			globalUser.u_error = User::myENFILE;
			return NULL;
		}
		else	/* ��������Inode�ɹ���������Inode�����·������ڴ�Inode */
		{
			/* �����µ��豸�š�����Inode���ţ��������ü������������ڵ����� */
			pInode->i_number = inumber;
			pInode->i_count++;

			BufferManager& bm = globalBufferManager;
			/* ��������Inode���뻺���� */
			Buf* pBuf = bm.Bread(FileSystem::INODE_ZONE_START_SECTOR + inumber / FileSystem::INODE_NUMBER_PER_SECTOR);


			/* ���������е�����Inode��Ϣ�������·������ڴ�Inode�� */
			pInode->ICopy(pBuf, inumber);
			/* �ͷŻ��� */
			bm.Brelse(pBuf);
			return pInode;
		}
	}

	cout << "111" << endl;
	exit(-1);

	return NULL;	/* GCC likes it! */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
leaq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpl %ebx, 0xc(%rcx)
jne 0x5eff
cmpl $0x0, (%rcx)
jne 0x5f11
incq %rax
addq $0x4c, %rcx
cmpq $0x64, %rax
jne 0x5ef5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x5f28
movl %eax, %eax
imulq $0x4c, %rax, %rax
leaq (%rdi,%rax), %r14
incl 0x8(%rdi,%rax)
jmp 0x5fe5
xorl %r14d, %r14d
xorl %eax, %eax
cmpl $0x0, 0x8(%rdi,%rax)
je 0x5f42
addq $0x4c, %rax
cmpq $0x1db0, %rax           # imm = 0x1DB0
jne 0x5f2d
jmp 0x5f48
addq %rax, %rdi
movq %rdi, %r14
testq %r14, %r14
je 0x5f8f
movl %ebx, 0x14(%r14)
incl 0x8(%r14)
leal 0x7(%rbx), %esi
testl %ebx, %ebx
cmovnsl %ebx, %esi
sarl $0x3, %esi
addl $0x2, %esi
leaq 0x72f6(%rip), %r15      # 0xd260
movq %r15, %rdi
callq 0x3af0
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x5c16
movq %r15, %rdi
movq %r12, %rsi
callq 0x3a9c
jmp 0x5fe5
movq 0x7032(%rip), %rbx      # 0xcfc8
leaq 0x30d7(%rip), %rsi      # 0x9074
movl $0x12, %edx
movq %rbx, %rdi
callq 0x3260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
leaq 0x17c00(%rip), %rax     # 0x1dbd8
movl $0x17, 0x10c8(%rax)
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::User()
User::User() {
    u_error = myNOERROR;
    u_FileManager = &globalFileManager;
    u_dirp = "/";
    u_curdir = "/";
    //u_FileManager->Open();
    u_cdir = u_FileManager->rootDirInode;
    u_pdir = NULL;
    memset(u_arg, 0, sizeof(u_arg));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
leaq 0x1038(%rdi), %rax
movq %rax, -0x48(%rbp)
leaq 0x1048(%rdi), %rax
movq %rax, -0x40(%rbp)
movq %rax, 0x1038(%rdi)
xorl %eax, %eax
movq %rax, 0x1040(%rdi)
movb %al, 0x1048(%rdi)
leaq 0x10a8(%rdi), %r14
leaq 0x10b8(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, 0x10a8(%rdi)
movq %rax, 0x10b0(%rdi)
movb %al, 0x10b8(%rdi)
leaq 0x10d0(%rdi), %r15
movq %r15, %rdi
callq 0x4392
leaq 0x13f0(%r12), %r13
movq %r13, %rdi
callq 0x442a
leaq 0x1418(%r12), %rbx
movq %rbx, 0x1408(%r12)
movq $0x0, 0x1410(%r12)
movb $0x0, 0x1418(%r12)
movl $0x0, 0x10c8(%r12)
leaq 0x179e7(%rip), %rax     # 0x1dbb8
movq %rax, 0x1400(%r12)
movq 0x1040(%r12), %rdx
leaq 0x2ec4(%rip), %rcx      # 0x90ac
movl $0x1, %r8d
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x3370
movq 0x10b0(%r12), %rdx
leaq 0x2ea4(%rip), %rcx      # 0x90ac
movl $0x1, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3370
movq 0x1400(%r12), %rax
movq (%rax), %rax
movq %rax, 0x1058(%r12)
movq $0x0, 0x1060(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x1020(%r12)
movl $0x0, 0x1030(%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
jmp 0x628e
movq %rax, -0x30(%rbp)
jmp 0x6296
movq %rax, -0x30(%rbp)
movq 0x1408(%r12), %rdi
cmpq %rbx, %rdi
je 0x6286
movq (%rbx), %rsi
incq %rsi
callq 0x3220
movq %r13, %rdi
callq 0x4430
movq %r15, %rdi
callq 0x43a4
movq (%r14), %rdi
cmpq -0x38(%rbp), %rdi
je 0x62ae
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3220
movq -0x48(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0x62ca
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3220
movq -0x30(%rbp), %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Ls()
void User::Ls() {
    ls.clear();
    u_FileManager->Ls();
    if (IsError()) {
        return;
    }
    cout << ls << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x1410(%rdi)
movq 0x1408(%rdi), %rax
movb $0x0, (%rax)
movq 0x1400(%rdi), %rdi
callq 0x4c06
movq %rbx, %rdi
callq 0x63e4
testb %al, %al
je 0x6399
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x1408(%rbx), %rsi
movq 0x1410(%rbx), %rdx
movq 0x6c1a(%rip), %rdi      # 0xcfc8
callq 0x3260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::IsError()
bool User::IsError() {
    if (u_error != myNOERROR) {
        cout << "errno = " << u_error;
        EchoError(u_error);
        u_error = myNOERROR;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x10c8(%rdi), %r15d
testl %r15d, %r15d
je 0x643b
movq %rdi, %rbx
movq 0x6bc4(%rip), %r14      # 0xcfc8
leaq 0x2deb(%rip), %rsi      # 0x91f6
movl $0x8, %edx
movq %r14, %rdi
callq 0x3260
movl 0x10c8(%rbx), %esi
movq %r14, %rdi
callq 0x33c0
movl 0x10c8(%rbx), %esi
callq 0x7642
movl $0x0, 0x10c8(%rbx)
testl %r15d, %r15d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Mkdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Mkdir(string dirName) {
    if (!checkPathName(dirName)) {
        return;
    }
    u_arg[1] = Inode::IFDIR;
    u_FileManager->Creat();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x77a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64ee
movl %eax, %r14d
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x64a0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r14b, %r14b
je 0x64c3
movl $0x4000, 0x1024(%rbx)   # imm = 0x4000
movq 0x1400(%rbx), %rdi
callq 0x483a
movq %rbx, %rdi
callq 0x63e4
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x64e6
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Cd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Cd(string dirName) {
    if (!checkPathName(dirName)) {
        return;
    }
    u_FileManager->ChDir();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x77a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64ee
movl %eax, %r14d
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x68b6
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r14b, %r14b
je 0x68cf
movq 0x1400(%rbx), %rdi
callq 0x4da6
movq %rbx, %rdi
callq 0x63e4
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x68f2
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Create(string fileName, string mode) {
    if (!checkPathName(fileName)) {
        return;
    }
    int md = INodeMode(mode);
    if (md == 0) {
        cout << "this mode is undefined !  \n";
        return;
    }

    u_arg[1] = md;
    u_FileManager->Creat();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x77a6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64ee
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6954
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r15b, %r15b
je 0x69d1
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x77a6
movq %r15, %rsi
callq 0x69fe
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6997
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3220
testl %r14d, %r14d
je 0x69b9
movl %r14d, 0x1024(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x483a
movq %rbx, %rdi
callq 0x63e4
jmp 0x69d1
movq 0x6608(%rip), %rdi      # 0xcfc8
leaq 0x26e7(%rip), %rsi      # 0x90ae
movl $0x1b, %edx
callq 0x3260
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x69f6
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::INodeMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int User::INodeMode(string mode) {
    int md = 0;
    if (mode.find("-r") != string::npos) {
        md |= Inode::IREAD;
    }
    if (mode.find("-w") != string::npos) {
        md |= Inode::IWRITE;
    }
    if (mode.find("-rw") != string::npos) {
        md |= (Inode::IREAD | Inode::IWRITE);
    }
    return md;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x27a0(%rip), %rsi      # 0x91b2
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
xorl %r14d, %r14d
cmpq $-0x1, %rax
setne %r14b
shll $0x8, %r14d
leaq 0x277e(%rip), %rsi      # 0x91b5
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
leal 0x80(%r14), %r15d
cmpq $-0x1, %rax
cmovel %r14d, %r15d
leaq 0x275c(%rip), %rsi      # 0x91b8
movl $0x3, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
cmpq $-0x1, %rax
movl $0x180, %eax            # imm = 0x180
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Delete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Delete(string fileName) {
    if (!checkPathName(fileName)) {
        return;
    }
    u_FileManager->UnLink();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x77a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64ee
movl %eax, %r14d
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6ad8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r14b, %r14b
je 0x6af1
movq 0x1400(%rbx), %rdi
callq 0x49f8
movq %rbx, %rdi
callq 0x63e4
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6b14
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Open(string fileName, string mode) {
    if (!checkPathName(fileName)) {
        return;
    }
    int md = FileMode(mode);
    if (md == 0) {
        cout << "Open����������\n";
        return;
    }

    u_arg[1] = md;
    u_FileManager->Open();
    if (IsError())
        return;
    cout << "�����ļ��ɹ������صľ���fd�ǣ�" << u_ar0[EAX] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x77a6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64ee
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6b76
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
testb %r15b, %r15b
je 0x6c4b
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x77a6
movq %r15, %rsi
callq 0x6c78
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6bbd
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3220
testl %r14d, %r14d
je 0x6c33
movl %r14d, 0x1024(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x4480
movq %rbx, %rdi
callq 0x63e4
testb %al, %al
jne 0x6c4b
movq 0x63e0(%rip), %r14      # 0xcfc8
leaq 0x24eb(%rip), %rsi      # 0x90da
movl $0x1e, %edx
movq %r14, %rdi
callq 0x3260
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x3160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
jmp 0x6c4b
movq 0x638e(%rip), %rdi      # 0xcfc8
leaq 0x2489(%rip), %rsi      # 0x90ca
movl $0xf, %edx
callq 0x3260
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x6c70
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::FileMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int User::FileMode(string mode) {
    int md = 0;
    if (mode.find("-r") != string::npos) {
        md |= File::FREAD;
    }
    if (mode.find("-w") != string::npos) {
        md |= File::FWRITE;
    }
    if (mode.find("-rw") != string::npos) {
        md |= (File::FREAD | File::FWRITE);
    }
    return md;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x2526(%rip), %rsi      # 0x91b2
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
xorl %r14d, %r14d
cmpq $-0x1, %rax
setne %r14b
leaq 0x2508(%rip), %rsi      # 0x91b5
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
leal 0x2(%r14), %r15d
cmpq $-0x1, %rax
cmovel %r14d, %r15d
leaq 0x24e9(%rip), %rsi      # 0x91b8
movl $0x3, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33d0
cmpq $-0x1, %rax
movl $0x3, %eax
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void User::Close(string sfd) {
    if (sfd.empty() || !isdigit(sfd.front())) {
        cout << "Close����������\n";
        return;
    }
    u_arg[0] = stoi(sfd);;
    u_FileManager->Close();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rsi)
je 0x6d87
movq (%rsi), %r15
movsbl (%r15), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x6d87
movq %rdi, %r14
callq 0x3050
movq %rax, %rbx
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x3310
cmpq %r15, (%r12)
je 0x6dad
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6db9
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x6db9
testl %ecx, %ecx
jne 0x6d5e
movl %r13d, (%rbx)
movl %eax, 0x1020(%r14)
movq 0x1400(%r14), %rdi
callq 0x498e
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63e4
movq 0x623a(%rip), %rdi      # 0xcfc8
leaq 0x2364(%rip), %rsi      # 0x90f9
movl $0x10, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3260
leaq 0x2503(%rip), %rdi      # 0x92b7
callq 0x3150
leaq 0x24f7(%rip), %rdi      # 0x92b7
callq 0x3320
cmpl $0x0, (%rbx)
jne 0x6dcd
movl %r13d, (%rbx)
movq %rax, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::EchoError(User::ErrorCode)
void User::EchoError(enum ErrorCode err) {
    string estr;
    switch (err) {
        case User::myNOERROR:
            estr = " No u_error ";
            break;
        case User::myENOENT:
            estr = " No such file or directory ";
            break;
        case User::myEBADF:
            estr = " Bad file number ";
            break;
        case User::myEACCES:
            estr = " Permission denied ";
            break;
        case User::myENOTDIR:
            estr = " Not a directory ";
            break;
        case User::myENFILE:
            estr = " File table overflow ";
            break;
        case User::myEMFILE:
            estr = " Too many open files ";
            break;
        case User::myEFBIG:
            estr = " File too large ";
            break;
        case User::myENOSPC:
            estr = " No space left on device ";
            break;
        default:
            break;
    }
    cout << estr << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
cmpl $0xc, %esi
jle 0x7690
leal -0x14(%rsi), %eax
cmpl $0x8, %eax
ja 0x76cf
leaq 0x1a13(%rip), %rcx      # 0x9088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x11, %r8d
leaq 0x1bc3(%rip), %rcx      # 0x924e
jmp 0x771d
testl %esi, %esi
je 0x76b1
cmpl $0x2, %esi
je 0x76c0
cmpl $0x9, %esi
jne 0x772a
movl $0x11, %r8d
leaq 0x1b79(%rip), %rcx      # 0x9228
jmp 0x771d
movl $0xc, %r8d
leaq 0x1b41(%rip), %rcx      # 0x91ff
jmp 0x771d
movl $0x1b, %r8d
leaq 0x1b3f(%rip), %rcx      # 0x920c
jmp 0x771d
cmpl $0xd, %esi
jne 0x772a
movl $0x13, %r8d
leaq 0x1b59(%rip), %rcx      # 0x923a
jmp 0x771d
movl $0x15, %r8d
leaq 0x1b86(%rip), %rcx      # 0x9276
jmp 0x771d
movl $0x15, %r8d
leaq 0x1b61(%rip), %rcx      # 0x9260
jmp 0x771d
movl $0x19, %r8d
leaq 0x1b8f(%rip), %rcx      # 0x929d
jmp 0x771d
movl $0x10, %r8d
leaq 0x1b6f(%rip), %rcx      # 0x928c
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3370
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x588f(%rip), %rdi      # 0xcfc8
callq 0x3260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x777d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3220
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x779e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/ljl0222[P]SecondFileSystem/common.cpp
// Function: getCmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> getCmd(string str)
{
	vector<string> result;
	result.clear();

	stringstream cmd(str); // ��str��Ϊ������
	string tempResult;
	while (cmd >> tempResult) {
		result.push_back(tempResult);
	}

	if (DEBUG) {
		cout << "����������������Ϊ" << endl;
		for (int cnt = 0; cnt < result.size(); cnt++) {
			cout << result[cnt] << ' ';
		}
		cout << endl;
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x854e
leaq -0x1d8(%rbp), %rdi
movq %r14, %rsi
movl $0x18, %edx
callq 0x3390
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x1d8(%rbp), %r14
leaq -0x50(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x78cb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8498
jmp 0x78a5
leaq 0x597f(%rip), %rax      # 0xd251
cmpb $0x1, (%rax)
jne 0x79b0
movq 0x56e6(%rip), %r14      # 0xcfc8
leaq 0x1a48(%rip), %rsi      # 0x9331
movl $0x12, %edx
movq %r14, %rdi
callq 0x3260
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq 0x56b4(%rip), %rdi      # 0xcfc8
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x797d
movl $0x8, %r13d
xorl %r14d, %r14d
movq 0x568e(%rip), %r15      # 0xcfc8
leaq -0x29(%rbp), %r12
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x3260
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3260
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %r14, %rcx
ja 0x793e
movq 0x5644(%rip), %rdi      # 0xcfc8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
leaq -0x40(%rbp), %r12
callq 0x31f0
movsbl %al, %esi
movq 0x5625(%rip), %rdi      # 0xcfc8
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x79c5
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3220
movq 0x55dc(%rip), %rsi      # 0xcfa8
leaq -0x1d8(%rbp), %rdi
callq 0x3190
leaq -0x158(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7a40
jmp 0x7a09
movq %rax, %r14
leaq -0x40(%rbp), %r12
jmp 0x7a0c
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x7a21
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3220
movq 0x5580(%rip), %rsi      # 0xcfa8
leaq -0x1d8(%rbp), %rdi
callq 0x3190
leaq -0x158(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x84e4
movq %r14, %rdi
callq 0x33e0