LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73a0(%rip), %rdi      # 0xc258
movq %rdi, 0x10(%rbx)
leaq 0x15b25(%rip), %rax     # 0x1a9e8
movq %rax, 0x8(%rbx)
leaq 0x7392(%rip), %rax      # 0xc260
movq %rax, (%rbx)
callq 0x4302
movq %rbx, %rdi
addq $0x8, %rsp
testb %al, %al
je 0x4ee8
popq %rbx
popq %rbp
jmp 0x50e8
popq %rbx
popq %rbp
jmp 0x4ef0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x338(%rax)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x31d0
movq 0x8(%rbx), %rcx
movl %eax, 0x340(%rcx)
xorl %r13d, %r13d
cmpq $0x400, %r13            # imm = 0x400
je 0x51a1
movq 0x8(%rbx), %r15
addq %r13, %r15
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x38e8
movq %rax, %r12
movq 0x20(%rax), %rdi
movl $0x200, %edx            # imm = 0x200
movq %r15, %rsi
callq 0x3190
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x3a86
addq $0x200, %r13            # imm = 0x200
incl %r14d
jmp 0x515b
leaq 0x15c58(%rip), %rdi     # 0x1ae00
callq 0x5f06
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b4c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x53e3
movq %rdi, %rbx
cmpl $0x1, %ecx
jg 0x53b5
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x3a46
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 0x3190
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x3a16
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x38e8
movq %rax, %r14
testq %rax, %rax
je 0x53d3
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3b36
movq 0x8(%rbx), %rax
movl $0x1, 0x338(%rax)
jmp 0x53fb
andl $0x0, 0x8(%rax)
leaq 0x177ea(%rip), %rax     # 0x1cbd8
movl $0x1c, 0x10c8(%rax)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/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 0x8(%rdi), %rax
movl 0x8(%rax), %ecx
cmpl $0x64, %ecx
jl 0x546b
movq %rdi, %r14
movq (%rdi), %rdi
movl %ebx, %esi
callq 0x38e8
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 0x3190
movq 0x8(%r14), %rax
andl $0x0, 0x8(%rax)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3a86
movq 0x8(%r14), %rax
movl 0x8(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rax)
movslq %ecx, %rcx
movl %ebx, 0xc(%rax,%rcx,4)
movl $0x1, 0x338(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/INode.cpp
// Function: Inode::ReadI()
void Inode::ReadI()
{
	int lbn;	/* �ļ��߼����� */
	int bn;		/* lbn��Ӧ�������̿��� */
	int offset;	/* ��ǰ�ַ�������ʼ����λ�� */
	int nbytes;	/* �������û�Ŀ�����ֽ����� */

	Buf* pBuf;

	User& u = globalUser;
	BufferManager& bufMgr = globalBufferManager;

	if (0 == u.u_IOParam.m_Count)
	{
		/* ��Ҫ���ֽ���Ϊ�㣬�򷵻� */
		return;
	}

	this->i_flag |= Inode::IACC;

	/* һ��һ���ַ����ض�������ȫ�����ݣ�ֱ�������ļ�β */
	while (User::myNOERROR == u.u_error && u.u_IOParam.m_Count != 0)
	{
		lbn = bn = u.u_IOParam.m_Offset / Inode::BLOCK_SIZE;
		offset = u.u_IOParam.m_Offset % Inode::BLOCK_SIZE;
		/* ���͵��û������ֽ�������ȡ��������ʣ���ֽ����뵱ǰ�ַ�������Ч�ֽ�����Сֵ */
		nbytes = min(Inode::BLOCK_SIZE - offset, u.u_IOParam.m_Count);

		if (1)
		{	/* ���������������豸�ļ� */

			int remain = this->i_size - u.u_IOParam.m_Offset;
			/* �����Ѷ��������ļ���β */
			if (remain <= 0)
			{
				return;
			}
			/* ���͵��ֽ�������ȡ����ʣ���ļ��ĳ��� */
			nbytes = min(nbytes, remain);

			/* ���߼�����lbnת���������̿���bn ��Bmap������Inode::rablock����UNIX��Ϊ��ȡԤ�����Ŀ���̫��ʱ��
			 * ������Ԥ������ʱ Inode::rablock ֵΪ 0��
			 * */
			if ((bn = this->Bmap(lbn)) == 0)
			{
				return;
			}
		}

		pBuf = bufMgr.Bread(bn);

		/* ��¼������ȡ�ַ������߼����� */
		this->i_lastr = lbn;

		/* ������������ʼ��λ�� */
		unsigned char* start = pBuf->b_addr + offset;

		/* ������: �ӻ������������û�Ŀ����
		 * i386оƬ��ͬһ��ҳ��ӳ���û��ռ����ں˿ռ䣬��һ��Ӳ���ϵĲ��� ʹ��i386��ʵ�� iomove����
		 * ��PDP-11Ҫ��������*/
		memcpy(u.u_IOParam.m_Base, start, nbytes);

		/* �ô����ֽ���nbytes���¶�дλ�� */
		u.u_IOParam.m_Base += nbytes;
		u.u_IOParam.m_Offset += nbytes;
		u.u_IOParam.m_Count -= nbytes;

		bufMgr.Brelse(pBuf);	/* ʹ���껺�棬�ͷŸ���Դ */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
leaq 0x176c9(%rip), %rbx     # 0x1cbd8
cmpl $0x0, 0x13fc(%rbx)
je 0x55f9
movq -0x30(%rbp), %rax
orb $0x4, (%rax)
cmpl $0x0, 0x10c8(%rbx)
jne 0x55f9
movl 0x13fc(%rbx), %r13d
testl %r13d, %r13d
je 0x55f9
movl 0x13f8(%rbx), %ecx
movl %ecx, %eax
cltd
movl $0x200, %esi            # imm = 0x200
idivl %esi
movl %eax, %r15d
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %ebx
subl %ecx, %ebx
jle 0x55f9
movl %edx, %r12d
movq -0x30(%rbp), %rdi
movl %r15d, %esi
callq 0x5608
testl %eax, %eax
je 0x55f9
movl $0x200, %r14d           # imm = 0x200
subl %r12d, %r14d
cmpl %r14d, %r13d
cmovll %r13d, %r14d
cmpl %r14d, %ebx
cmovll %ebx, %r14d
leaq 0x6cc9(%rip), %rdi      # 0xc260
movl %eax, %esi
callq 0x3a46
movq %rax, %r13
movq -0x30(%rbp), %rax
movl %r15d, 0x48(%rax)
movslq %r12d, %rsi
addq 0x20(%r13), %rsi
leaq 0x17621(%rip), %rax     # 0x1cbd8
movq 0x13f0(%rax), %rdi
movslq %r14d, %r15
leaq 0x17610(%rip), %rbx     # 0x1cbd8
movq %r15, %rdx
callq 0x3190
addq %r15, 0x13f0(%rbx)
addl %r15d, 0x13f8(%rbx)
subl %r15d, 0x13fc(%rbx)
leaq 0x6c74(%rip), %rdi      # 0xc260
movq %r13, %rsi
callq 0x3a16
jmp 0x5523
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5bc4
testb $0x6, (%rbx)
je 0x59e4
movl 0x14(%rbx), %eax
pushq $0x8
popq %r15
cltd
idivl %r15d
leal 0x2(%rax), %esi
leaq 0x6918(%rip), %rdi      # 0xc260
callq 0x3a46
movq %rax, %rsi
movl 0x4(%rbx), %eax
movl %eax, -0x58(%rbp)
movl 0xc(%rbx), %eax
movl %eax, -0x54(%rbp)
movzwl 0x18(%rbx), %eax
movw %ax, -0x50(%rbp)
movzwl 0x1a(%rbx), %eax
movw %ax, -0x4e(%rbp)
movl 0x1c(%rbx), %eax
movl %eax, -0x4c(%rbp)
pushq $0x8
popq %rax
cmpq $0x12, %rax
je 0x5987
movl (%rbx,%rax,4), %ecx
movl %ecx, -0x68(%rbp,%rax,4)
incq %rax
jmp 0x5975
movl (%rbx), %eax
testb $0x4, %al
je 0x5991
movl %r14d, -0x20(%rbp)
testb $0x2, %al
je 0x5999
movl %r14d, -0x1c(%rbp)
movq 0x20(%rsi), %rcx
movl 0x14(%rbx), %eax
cltd
idivl %r15d
movslq %edx, %rax
shlq $0x6, %rax
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movups -0x28(%rbp), %xmm3
movups %xmm3, 0x30(%rcx,%rax)
movups %xmm2, 0x20(%rcx,%rax)
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
leaq 0x688b(%rip), %rdi      # 0xc260
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a86
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %eax
movq 0x20(%rsi), %rcx
movl $0x8, %esi
cltd
idivl %esi
movslq %edx, %rax
shlq $0x6, %rax
addq %rcx, %rax
addq $0x10, %rax
movl -0x10(%rax), %ecx
movl %ecx, 0x4(%rdi)
movl -0xc(%rax), %ecx
movl %ecx, 0xc(%rdi)
movzwl -0x8(%rax), %ecx
movw %cx, 0x18(%rdi)
movzwl -0x6(%rax), %ecx
movw %cx, 0x1a(%rdi)
movl -0x4(%rax), %ecx
movl %ecx, 0x1c(%rdi)
addq $0x20, %rdi
xorl %ecx, %ecx
cmpq $0xa, %rcx
je 0x5bab
movl (%rax,%rcx,4), %edx
movl %edx, (%rdi,%rcx,4)
incq %rcx
jmp 0x5b9a
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rdi)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x633a(%rip), %rdi      # 0xbfc8
callq 0x4406
testl %eax, %eax
js 0x5ce2
addq $-0x18, %rbx
pushq $0x65
popq %rcx
decq %rcx
je 0x5cd1
leaq 0x18(%rbx), %r14
cmpl $0x0, 0x1c(%rbx)
movq %r14, %rbx
jne 0x5c9e
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x630c(%rip), %rdi      # 0xbfc8
movl %eax, %esi
movq %r14, %rdx
callq 0x4470
incl 0x4(%r14)
andl $0x0, 0x10(%r14)
jmp 0x5ce5
leaq 0x16f00(%rip), %rax     # 0x1cbd8
movl $0x17, 0x10c8(%rax)
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
jne 0x5d65
cmpl $0x0, 0xc(%rbx)
jg 0x5d4a
movq %rdi, %r14
movq %rbx, %rdi
callq 0x59f0
andl $0x0, 0x4(%rbx)
movq 0x1db0(%r14), %rdi
movl 0x14(%rbx), %esi
callq 0x5320
xorl %edi, %edi
callq 0x31d0
movq %rbx, %rdi
movl %eax, %esi
callq 0x590e
andl $0x0, (%rbx)
orl $-0x1, 0x14(%rbx)
movl 0x8(%rbx), %eax
decl %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movq %rdi, %r15
callq 0x5eb0
testl %eax, %eax
js 0x5e25
movl %eax, %eax
imulq $0x4c, %rax, %rax
leaq (%r15,%rax), %rbx
incl 0x8(%r15,%rax)
jmp 0x5ea3
movq %r15, %rdi
callq 0x5edc
testq %rax, %rax
je 0x5e75
movq %rax, %rbx
movl %r14d, 0x14(%rax)
incl 0x8(%rax)
pushq $0x8
popq %rcx
movl %r14d, %eax
cltd
idivl %ecx
leal 0x2(%rax), %esi
leaq 0x6411(%rip), %r15      # 0xc260
movq %r15, %rdi
callq 0x3a46
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x5b52
movq %r15, %rdi
movq %r12, %rsi
callq 0x3a16
jmp 0x5ea3
movq 0x6144(%rip), %rdi      # 0xbfc0
leaq 0x21f1(%rip), %rsi      # 0x8074
callq 0x31e0
movq %rax, %rdi
callq 0x3100
leaq 0x16d41(%rip), %rax     # 0x1cbd8
movl $0x17, 0x10c8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/OpenFileManager.cpp
// Function: InodeTable::IsLoaded(int)
int InodeTable::IsLoaded(int inumber)
{
	/* Ѱ��ָ������Inode���ڴ濽�� */
	for (int i = 0; i < InodeTable::NINODE; i++)
	{
		if (this->m_Inode[i].i_number == inumber && this->m_Inode[i].i_count != 0)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $0x8, %rdi
xorl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x64, %rcx
je 0x5eda
cmpl %esi, 0xc(%rdi)
jne 0x5ecf
cmpl $0x0, (%rdi)
jne 0x5ed8
incq %rcx
addq $0x4c, %rdi
jmp 0x5ebf
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/OpenFileManager.cpp
// Function: InodeTable::GetFreeInode()
Inode* InodeTable::GetFreeInode()
{
	for (int i = 0; i < InodeTable::NINODE; i++)
	{
		/* �������ڴ�Inode���ü���Ϊ�㣬����Inode��ʾ���� */
		if (this->m_Inode[i].i_count == 0)
		{
			return m_Inode + i;
		}
	}
	return NULL;	/* Ѱ��ʧ�� */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $-0x4c, %rdi
movabsq $0x65, %rcx
decq %rcx
je 0x5f02
leaq 0x4c(%rdi), %rax
cmpl $0x0, 0x54(%rdi)
movq %rax, %rdi
jne 0x5eee
jmp 0x5f04
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/OpenFileManager.cpp
// Function: InodeTable::UpdateInodeTable()
void InodeTable::UpdateInodeTable()
{
	for (int i = 0; i < InodeTable::NINODE; i++)
	{
		/*
		 * ����Inode����û�б�����������ǰδ����������ʹ�ã�����ͬ��������Inode��
		 * ����count������0��count == 0��ζ�Ÿ��ڴ�Inodeδ���κδ����ļ����ã�����ͬ����
		 */
		if (this->m_Inode[i].i_count != 0)
		{
			this->m_Inode[i].IUpdate((int)time(NULL));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x1db0, %r15           # imm = 0x1DB0
je 0x5f42
cmpl $0x0, 0x8(%rbx,%r15)
je 0x5f3c
leaq (%rbx,%r15), %r14
xorl %edi, %edi
callq 0x31d0
movq %r14, %rdi
movl %eax, %esi
callq 0x590e
addq $0x4c, %r15
jmp 0x5f16
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %r12
leaq 0x1048(%rdi), %rax
movq %rax, 0x1038(%rdi)
andq $0x0, 0x1040(%rdi)
xorl %eax, %eax
movb %al, 0x1048(%rdi)
leaq 0x10b8(%rdi), %rcx
movq %rcx, 0x10a8(%rdi)
andq $0x0, 0x10b0(%rdi)
leaq 0x1038(%rdi), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x10a8(%rdi), %r14
movb %al, 0x10b8(%rdi)
leaq 0x10d0(%rdi), %r15
movq %r15, %rdi
callq 0x43ee
leaq 0x13f0(%r12), %r13
movq %r13, %rdi
callq 0x4482
leaq 0x1418(%r12), %rax
movq %rax, 0x1408(%r12)
andq $0x0, 0x1410(%r12)
movb $0x0, 0x1418(%r12)
andl $0x0, 0x10c8(%r12)
leaq 0x1408(%r12), %rbx
leaq 0x16b22(%rip), %rax     # 0x1cbb8
movq %rax, 0x1400(%r12)
leaq 0x2007(%rip), %rsi      # 0x80ac
movq -0x30(%rbp), %rdi
callq 0x33f0
leaq 0x1ff7(%rip), %rsi      # 0x80ac
movq %r14, %rdi
callq 0x33f0
movq 0x1400(%r12), %rax
movq (%rax), %rax
movq %rax, 0x1058(%r12)
andq $0x0, 0x1060(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x1020(%r12)
andl $0x0, 0x1030(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x611a
movq %rax, %r12
jmp 0x6122
movq %rax, %r12
movq %rbx, %rdi
callq 0x3448
movq %r13, %rdi
callq 0x4488
movq %r15, %rdi
callq 0x4400
movq %r14, %rdi
callq 0x3448
movq -0x30(%rbp), %rdi
callq 0x3448
movq %r12, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x1410(%rdi)
movq 0x1408(%rdi), %rax
movb $0x0, (%rax)
movq 0x1400(%rdi), %rdi
callq 0x4c3e
movq %rbx, %rdi
callq 0x61e8
testb %al, %al
je 0x61c4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x1408, %rbx           # imm = 0x1408
movq 0x5dee(%rip), %rdi      # 0xbfc0
movq %rbx, %rsi
callq 0x31c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movl 0x10c8(%rdi), %r14d
testl %r14d, %r14d
je 0x6231
movq %rdi, %rbx
movq 0x5dbb(%rip), %rdi      # 0xbfc0
leaq 0x1fea(%rip), %rsi      # 0x81f6
callq 0x31e0
movl 0x10c8(%rbx), %esi
movq %rax, %rdi
callq 0x33b0
movl 0x10c8(%rbx), %esi
callq 0x6d44
andl $0x0, 0x10c8(%rbx)
testl %r14d, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3310
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62ae
movl %eax, %r14d
leaq -0x30(%rbp), %rdi
callq 0x3448
testb %r14b, %r14b
je 0x6290
movl $0x4000, 0x1024(%rbx)   # imm = 0x4000
movq 0x1400(%rbx), %rdi
callq 0x4892
movq %rbx, %rdi
callq 0x61e8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3310
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62ae
movl %eax, %r14d
leaq -0x30(%rbp), %rdi
callq 0x3448
testb %r14b, %r14b
je 0x653e
movq 0x1400(%rbx), %rdi
callq 0x4dd8
movq %rbx, %rdi
callq 0x61e8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3310
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62ae
movl %eax, %r15d
leaq -0x38(%rbp), %rdi
callq 0x3448
testb %r15b, %r15b
je 0x65ee
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3310
movq %r15, %rsi
callq 0x660e
movl %eax, %r14d
movq %r15, %rdi
callq 0x3448
testl %r14d, %r14d
je 0x65db
movl %r14d, 0x1024(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x4892
movq %rbx, %rdi
callq 0x61e8
jmp 0x65ee
movq 0x59de(%rip), %rdi      # 0xbfc0
leaq 0x1ac5(%rip), %rsi      # 0x80ae
callq 0x31e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b90(%rip), %rsi      # 0x81b2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3430
xorl %r14d, %r14d
cmpq $-0x1, %rax
setne %r14b
shll $0x8, %r14d
leaq 0x1b73(%rip), %rsi      # 0x81b5
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3430
leal 0x80(%r14), %r15d
cmpq $-0x1, %rax
cmovel %r14d, %r15d
leaq 0x1b56(%rip), %rsi      # 0x81b8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
movl $0x180, %eax            # imm = 0x180
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3310
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62ae
movl %eax, %r14d
leaq -0x30(%rbp), %rdi
callq 0x3448
testb %r14b, %r14b
je 0x66ce
movq 0x1400(%rbx), %rdi
callq 0x4a42
movq %rbx, %rdi
callq 0x61e8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3310
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62ae
movl %eax, %r15d
leaq -0x38(%rbp), %rdi
callq 0x3448
testb %r15b, %r15b
je 0x67ac
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3310
movq %r15, %rsi
callq 0x67cc
movl %eax, %r14d
movq %r15, %rdi
callq 0x3448
testl %r14d, %r14d
je 0x6799
movl %r14d, 0x1024(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x44d8
movq %rbx, %rdi
callq 0x61e8
testb %al, %al
jne 0x67ac
movq 0x5848(%rip), %rdi      # 0xbfc0
leaq 0x195b(%rip), %rsi      # 0x80da
callq 0x31e0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3150
movq %rax, %rdi
callq 0x3100
jmp 0x67ac
movq 0x5820(%rip), %rdi      # 0xbfc0
leaq 0x1923(%rip), %rsi      # 0x80ca
callq 0x31e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19d2(%rip), %rsi      # 0x81b2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3430
xorl %r14d, %r14d
cmpq $-0x1, %rax
setne %r14b
leaq 0x19b9(%rip), %rsi      # 0x81b5
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3430
leal 0x2(%r14), %r15d
cmpq $-0x1, %rax
cmovel %r14d, %r15d
leaq 0x199f(%rip), %rsi      # 0x81b8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
pushq $0x3
popq %rax
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Seek(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::Seek(string sfd, string offset, string origin) {
    if (sfd.empty() || !isdigit(sfd.front())) {
        cout << "Seek����������\n";
        return;
    }
    if (offset.empty()) {
        cout << "Seek����������\n";
        return;
    }
    if (origin.empty() || !isdigit(origin.front())) {
        cout << "Seek����������\n";
        return;
    }
    u_arg[0] = stoi(sfd);
    u_arg[1] = stoi(offset);
    u_arg[2] = stoi(origin);
    u_FileManager->Seek();
    IsError();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x8(%rsi)
je 0x693a
movq (%rsi), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x693a
movq %rdx, %r15
cmpq $0x0, 0x8(%rdx)
je 0x693a
movq %rcx, %r14
cmpq $0x0, 0x8(%rcx)
je 0x693a
movq (%r14), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x693a
movq %rdi, %rbx
pushq $0xa
popq %r12
movq %rsi, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x6e1c
movl %eax, 0x1020(%rbx)
movq %r15, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x6e1c
movl %eax, 0x1024(%rbx)
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x6e1c
movl %eax, 0x1028(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x4aec
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61e8
movq 0x567f(%rip), %rdi      # 0xbfc0
leaq 0x17c2(%rip), %rsi      # 0x810a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::Write(string sfd, string inFile, string size) {
    if (sfd.empty() || !isdigit(sfd.front())) {
        cout << "write����������\n";
        return;
    }
    int fd = stoi(sfd);

    int usize;
    if (size.empty() || (usize = stoi(size)) < 0) {
        cout << "write����������\n";
        return;
    }

    char* buffer = new char[usize];
    fstream fin(inFile, ios::in | ios::binary);
    if (!fin) {
        cout << "���������ļ�  " << inFile << " ʧ�ܣ�\n";
        return;
    }
    fin.read(buffer, usize);
    fin.close();
    u_arg[0] = fd;
    u_arg[1] = (long)buffer;
    u_arg[2] = usize;
    u_FileManager->Write();

    if (IsError())
        return;
    cout << "������д�� " << u_ar0[User::EAX] << "�ֽڳɹ���" << endl;
    delete[]buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
cmpq $0x0, 0x8(%rsi)
je 0x6a2b
movq (%rsi), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x6a2b
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
pushq $0xa
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x6e1c
cmpq $0x0, 0x8(%r14)
je 0x6a2b
movl %eax, %r12d
pushq $0xa
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x6e1c
testl %eax, %eax
js 0x6a2b
movl %eax, %r13d
movl %r12d, -0x2c(%rbp)
movl %eax, %r14d
movq %r14, %rdi
callq 0x3030
movq %rax, -0x38(%rbp)
leaq -0x248(%rbp), %r12
pushq $0xc
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x33a0
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x228(%rbp,%rax)
je 0x6a4f
movq 0x55c0(%rip), %rdi      # 0xbfc0
leaq 0x1724(%rip), %rsi      # 0x812b
callq 0x31e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31c0
leaq 0x171c(%rip), %rsi      # 0x813a
movq %rax, %rdi
callq 0x31e0
jmp 0x6add
movq 0x558e(%rip), %rdi      # 0xbfc0
leaq 0x16e1(%rip), %rsi      # 0x811a
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
leaq -0x248(%rbp), %rdi
movq -0x38(%rbp), %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x32a0
leaq -0x248(%rbp), %rdi
callq 0x3060
movl -0x2c(%rbp), %eax
movl %eax, 0x1020(%rbx)
movl %r15d, 0x1024(%rbx)
movl %r13d, 0x1028(%rbx)
movq 0x1400(%rbx), %rdi
callq 0x4c2e
movq %rbx, %rdi
callq 0x61e8
testb %al, %al
jne 0x6add
movq 0x5519(%rip), %rdi      # 0xbfc0
leaq 0x1695(%rip), %rsi      # 0x8143
callq 0x31e0
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x3150
leaq 0x168a(%rip), %rsi      # 0x814f
movq %rax, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x3100
movq %r15, %rdi
callq 0x32c0
leaq -0x248(%rbp), %rdi
callq 0x3090
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leal -0x14(%rsi), %eax
cmpl $0x8, %eax
ja 0x6d7e
leaq 0x131c(%rip), %rcx      # 0x8088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x14d2(%rip), %rsi      # 0x824e
jmp 0x6dd7
cmpl $0xd, %esi
je 0x6dd0
cmpl $0x2, %esi
je 0x6dc7
cmpl $0x9, %esi
je 0x6dbe
testl %esi, %esi
jne 0x6de0
leaq 0x1467(%rip), %rsi      # 0x81ff
jmp 0x6dd7
leaq 0x14d5(%rip), %rsi      # 0x8276
jmp 0x6dd7
leaq 0x14e2(%rip), %rsi      # 0x828c
jmp 0x6dd7
leaq 0x14ea(%rip), %rsi      # 0x829d
jmp 0x6dd7
leaq 0x14a4(%rip), %rsi      # 0x8260
jmp 0x6dd7
leaq 0x1463(%rip), %rsi      # 0x8228
jmp 0x6dd7
leaq 0x143e(%rip), %rsi      # 0x820c
jmp 0x6dd7
leaq 0x1463(%rip), %rsi      # 0x823a
leaq -0x28(%rbp), %rdi
callq 0x33f0
movq 0x51d9(%rip), %rdi      # 0xbfc0
leaq -0x28(%rbp), %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3100
leaq -0x28(%rbp), %rdi
callq 0x3448
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x76fc
leaq -0x1d0(%rbp), %rdi
pushq $0x18
popq %rdx
movq %r14, %rsi
callq 0x3370
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1d0(%rbp), %r14
leaq -0x48(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6fdd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x770a
jmp 0x6fb7
leaq 0x526d(%rip), %rax      # 0xc251
cmpb $0x1, (%rax)
jne 0x7053
movq 0x4fd0(%rip), %rdi      # 0xbfc0
leaq 0x12c5(%rip), %rsi      # 0x82bc
callq 0x31e0
movq %rax, %rdi
callq 0x3100
xorl %r12d, %r12d
movq 0x4fb2(%rip), %r14      # 0xbfc0
pushq $0x20
popq %r15
xorl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x7047
addq %r12, %rsi
movq %r14, %rdi
callq 0x31c0
movq %rax, %rdi
movl %r15d, %esi
callq 0x3250
incq %r13
addq $0x20, %r12
jmp 0x7015
movq 0x4f72(%rip), %rdi      # 0xbfc0
callq 0x3100
leaq -0x48(%rbp), %rdi
callq 0x3448
leaq -0x1d0(%rbp), %rdi
callq 0x3170
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x709e
jmp 0x7086
jmp 0x7086
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x3448
leaq -0x1d0(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x7746
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/ljl0222[P]SecondFileSystem/main.cpp
// Function: main
int main()
{
	DEBUG = false;


	while (1) {
		cout << "[u1851977@localhost " + globalUser.u_curdir + "]$ ";
		getline(cin, line);

		vector<string> cmdList = getCmd(line); // ��ʱ��һ����Ϊ������

		exeCmd(cmdList);

	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movb $0x0, 0x4761(%rip)      # 0xc251
leaq -0xa0(%rbp), %r15
leaq -0x48(%rbp), %r13
leaq 0x164fe(%rip), %r12     # 0x1e000
leaq -0x80(%rbp), %rbx
leaq -0x60(%rbp), %r14
movq %r15, %rdi
leaq 0x86e(%rip), %rsi       # 0x8382
leaq 0x16165(%rip), %rdx     # 0x1dc80
callq 0x7c19
movq %r13, %rdi
movq %r15, %rsi
leaq 0x86a(%rip), %rdx       # 0x8397
callq 0x7bf0
movq 0x4487(%rip), %rdi      # 0xbfc0
movq %r13, %rsi
callq 0x31c0
movq %r13, %rdi
callq 0x3448
movq %r15, %rdi
callq 0x3448
movq 0x4488(%rip), %rdi      # 0xbfe0
movq %r12, %rsi
callq 0x3080
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3310
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6f60
movq %rbx, %rdi
callq 0x3448
movq %r14, %rdi
movq %r13, %rsi
callq 0x7c90
movq %r14, %rdi
callq 0x70ae
movq %r14, %rdi
callq 0x7746
movq %r13, %rdi
callq 0x7746
jmp 0x7b0a
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x7746
jmp 0x7bb7
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x7746
jmp 0x7be8
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x7be3
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3448
jmp 0x7bdc
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: refDataset()
void refDataset()
{
    dataMapper.insert({"htpl", "#include<stdio.h>\n"});
    dataMapper.insert({"main", "void main(){\n"});
    dataMapper.insert({"log", "printf()"});
    dataMapper.insert({"/log", ";"});
    dataMapper.insert({"/", "}"});
    dataMapper.insert({"in", "int"});
    dataMapper.insert({"ch", "char"});
    dataMapper.insert({"int", "%d"});
    dataMapper.insert({"char", "%c"});
    dataMapper.insert({"take", "scanf()"});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
leaq 0x3b04(%rip), %rsi      # 0x6020
leaq 0x3b02(%rip), %rdx      # 0x6025
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d78
leaq 0x6c6a(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x3aea(%rip), %rsi      # 0x6038
leaq 0x3ae8(%rip), %rdx      # 0x603d
movq %rbx, %rdi
callq 0x4dde
leaq 0x6c3c(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x3ad9(%rip), %rsi      # 0x6055
leaq 0x3ac8(%rip), %rdx      # 0x604b
movq %rbx, %rdi
callq 0x4e24
leaq 0x6c0e(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x3aaa(%rip), %rsi      # 0x6054
leaq 0x3aa8(%rip), %rdx      # 0x6059
movq %rbx, %rdi
callq 0x4e6a
leaq 0x6be0(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x3a83(%rip), %rsi      # 0x605b
leaq 0x3a7e(%rip), %rdx      # 0x605d
movq %rbx, %rdi
callq 0x4eb0
leaq 0x6bb2(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x3a34(%rip), %rsi      # 0x603a
leaq 0x3a52(%rip), %rdx      # 0x605f
movq %rbx, %rdi
callq 0x4ef6
leaq 0x6b84(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x3a2f(%rip), %rsi      # 0x6063
leaq 0x3a2b(%rip), %rdx      # 0x6066
movq %rbx, %rdi
callq 0x4f3c
leaq 0x6b56(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x39fd(%rip), %rsi      # 0x605f
leaq 0x3a02(%rip), %rdx      # 0x606b
movq %rbx, %rdi
callq 0x4f82
leaq 0x6b28(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x39d6(%rip), %rsi      # 0x6066
leaq 0x39d7(%rip), %rdx      # 0x606e
movq %rbx, %rdi
callq 0x4fc8
leaq 0x6afa(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
leaq 0x39b3(%rip), %rsi      # 0x6071
leaq 0x39b1(%rip), %rdx      # 0x6076
movq %rbx, %rdi
callq 0x500e
leaq 0x6acc(%rip), %rdi      # 0x91a0
movq %rbx, %rsi
callq 0x54ac
leaq -0x48(%rbp), %rdi
callq 0x4dbe
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x26fe
jmp 0x26fe
jmp 0x26fe
jmp 0x26fe
jmp 0x26fe
jmp 0x26fe
jmp 0x26fe
jmp 0x26fe
jmp 0x26fe
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4dbe
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: removeFrontSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string removeFrontSpaces(std::string getData)
{
    for (int i = 0; i < getData.length(); i++)
    {
        if (getData[i] != ' ')
        {
            getData = getData.substr(i, getData.length() - i);
            break;
        }
    }
    return getData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x276b
movq (%r14), %rsi
leaq 0x1(%rax), %rdx
cmpb $0x20, (%rsi,%rax)
movq %rdx, %rax
je 0x272b
subq %rdx, %rcx
incq %rcx
decq %rdx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x21b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Shaviaditya[P]CReact-Esoteric-Language/transpiler1.cpp
// Function: writeCode()
void writeCode()
{
    std::ofstream writeFile("output.c");
    for (int i = 0; i < setParserData.size() - 1; i++)
    {
        writeFile << setParserData[i] << "\n";
        if (i == 0)
        {
            for (int k = 0; k < functionHeader.size(); k++)
            {
                writeFile << functionHeader[k] << "\n";
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq 0x38ab(%rip), %rsi      # 0x607e
leaq -0x228(%rbp), %rbx
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x21d0
xorl %r15d, %r15d
leaq 0x3847(%rip), %r14      # 0x6036
movq 0x6a22(%rip), %rax      # 0x9218
movq 0x6a13(%rip), %rsi      # 0x9210
subq %rsi, %rax
sarq $0x5, %rax
decq %rax
cmpq %r15, %rax
jbe 0x2872
movq %r15, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
testq %r15, %r15
je 0x2833
incq %r15
jmp 0x27ef
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x69f0(%rip), %rax      # 0x9230
movq 0x69e1(%rip), %rsi      # 0x9228
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x282e
addq %r12, %rsi
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
incq %r13
addq $0x20, %r12
jmp 0x2839
leaq -0x228(%rbp), %rdi
callq 0x2240
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2892
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x2290