LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
leaq 0x1d1cd(%rip), %rax     # 0x24cc8
movq %rax, -0x28(%rbp)
movq 0x8(%rcx), %rax
movq 0x8(%rcx), %rdx
movl 0x8(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rdx)
movslq %ecx, %rcx
movl 0xc(%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jl 0x7b4e
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x0, 0x8(%rax)
leaq 0x1d191(%rip), %rax     # 0x24cc8
movl $0x1c, 0x10c8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x7c04
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x8(%rax)
jg 0x7bc0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x3f10
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x4, %rdx
movq %rdx, -0x30(%rbp)
movl (%rcx), %edx
movq 0x8(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x8(%rax), %rdi
addq $0xc, %rdi
movq -0x30(%rbp), %rsi
movl $0x190, %edx            # imm = 0x190
callq 0x3260
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3e80
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x3ca0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7bea
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x40c0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x338(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1d09a(%rip), %rcx     # 0x24cc8
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
cmpl $0x64, 0x8(%rax)
jl 0x7cab
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x3ca0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movl 0x8(%rcx), %edx
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
movl %edx, (%rcx)
movq -0x28(%rbp), %rdi
movq 0x8(%rax), %rsi
addq $0xc, %rsi
movl $0x190, %edx            # imm = 0x190
callq 0x3260
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x0, 0x8(%rcx)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3fa0
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x8(%rax), %rcx
movq 0x8(%rax), %rdi
movl 0x8(%rdi), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, 0x8(%rdi)
movslq %edx, %rdx
movl %esi, 0xc(%rcx,%rdx,4)
movq 0x8(%rax), %rax
movl $0x1, 0x338(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ljl0222[P]SecondFileSystem/FileSystem.cpp
// Function: FileSystem::FormatSuperBlock()
void FileSystem::FormatSuperBlock()
{
	m_SuperBlock->s_isize = FileSystem::INODE_ZONE_SIZE;


	m_SuperBlock->s_fsize = FileSystem::DISK_SIZE;


	m_SuperBlock->s_nfree = 0;
	m_SuperBlock->s_free[0] = -1;
	m_SuperBlock->s_ninode = 0;
	m_SuperBlock->s_flock = 0;
	m_SuperBlock->s_ilock = 0;
	m_SuperBlock->s_fmod = 0;
	m_SuperBlock->s_ronly = 0;

	time((time_t*)&m_SuperBlock->s_time); // ���·���ʱ��
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x3fe, (%rcx)          # imm = 0x3FE
movq 0x8(%rax), %rcx
movl $0x4000, 0x4(%rcx)      # imm = 0x4000
movq 0x8(%rax), %rcx
movl $0x0, 0x8(%rcx)
movq 0x8(%rax), %rcx
movl $0xffffffff, 0xc(%rcx)  # imm = 0xFFFFFFFF
movq 0x8(%rax), %rcx
movl $0x0, 0x19c(%rcx)
movq 0x8(%rax), %rcx
movl $0x0, 0x330(%rcx)
movq 0x8(%rax), %rcx
movl $0x0, 0x334(%rcx)
movq 0x8(%rax), %rcx
movl $0x0, 0x338(%rcx)
movq 0x8(%rax), %rcx
movl $0x0, 0x33c(%rcx)
movq 0x8(%rax), %rdi
addq $0x340, %rdi            # imm = 0x340
callq 0x32c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ljl0222[P]SecondFileSystem/INode.cpp
// Function: Inode::Inode()
Inode::Inode()
{
	/* ����Inode�����е����� */
	// this->Clean(); 
	/* ȥ��this->Clean();�����ɣ�
	 * Inode::Clean()�ض�����IAlloc()�������·���DiskInode��ԭ�����ݣ�
	 * �����ļ���Ϣ��Clean()�����в�Ӧ������i_dev, i_number, i_flag, i_count,
	 * ���������ڴ�Inode����DiskInode�����ľ��ļ���Ϣ����Inode�๹�캯����Ҫ
	 * ������ʼ��Ϊ��Чֵ��
	 */

	 /* ��Inode�����ĳ�Ա������ʼ��Ϊ��Чֵ */
	this->i_flag = 0;
	this->i_mode = 0;
	this->i_count = 0;
	this->i_nlink = 0;
	this->i_dev = -1;
	this->i_number = -1;
	this->i_uid = -1;
	this->i_gid = -1;
	this->i_size = 0;
	this->i_lastr = -1;
	for (int i = 0; i < 10; i++)
	{
		this->i_addr[i] = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movw $0xffff, 0x10(%rax)     # imm = 0xFFFF
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movw $0xffff, 0x18(%rax)     # imm = 0xFFFF
movw $0xffff, 0x1a(%rax)     # imm = 0xFFFF
movl $0x0, 0x1c(%rax)
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x7e0a
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, 0x20(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7de9
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movl -0x14(%rbp), %eax
movl $0x8, %esi
cltd
idivl %esi
movq -0x30(%rbp), %rax
movslq %edx, %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rcx
movw 0x8(%rcx), %cx
movw %cx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movw 0xa(%rcx), %cx
movw %cx, 0x1a(%rax)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, -0x24(%rbp)
cmpl $0xa, -0x24(%rbp)
jge 0x89e5
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movl 0x10(%rcx,%rdx,4), %edx
movslq -0x24(%rbp), %rcx
movl %edx, 0x20(%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x89bc
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
movl $0x28, %edx
callq 0x3260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ljl0222[P]SecondFileSystem/INode.cpp
// Function: DiskInode::DiskInode()
DiskInode::DiskInode()
{
	/*
	 * ����DiskInodeû�й��캯�����ᷢ�����½��Ѳ����Ĵ�����
	 * DiskInode��Ϊ�ֲ�����ռ�ݺ���Stack Frame�е��ڴ��ռ䣬����
	 * ���οռ�û�б���ȷ��ʼ�����Ծɱ�������ǰջ���ݣ����ڲ�����
	 * DiskInode�����ֶζ��ᱻ���£���DiskInodeд�ص�������ʱ������
	 * ����ǰջ����һͬд�أ�����д�ؽ�������Ī�����������ݡ�
	 */
	this->d_mode = 0;
	this->d_nlink = 0;
	this->d_uid = -1;
	this->d_gid = -1;
	this->d_size = 0;
	for (int i = 0; i < 10; i++)
	{
		this->d_addr[i] = 0;
	}
	this->d_atime = 0;
	this->d_mtime = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movw $0xffff, 0x8(%rax)      # imm = 0xFFFF
movw $0xffff, 0xa(%rax)      # imm = 0xFFFF
movl $0x0, 0xc(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x8a68
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, 0x10(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8a47
movq -0x18(%rbp), %rax
movl $0x0, 0x38(%rax)
movl $0x0, 0x3c(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1c0ed(%rip), %rax     # 0x24cc8
movq %rax, -0x20(%rbp)
leaq 0x1c0e2(%rip), %rdi     # 0x24cc8
addq $0x10d0, %rdi           # imm = 0x10D0
callq 0x6240
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x8c08
movq $0x0, -0x8(%rbp)
jmp 0x8cbd
movl $0x0, -0x24(%rbp)
cmpl $0x64, -0x24(%rbp)
jge 0x8ca4
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jne 0x8c94
movq -0x30(%rbp), %rdx
movl -0x14(%rbp), %esi
movslq -0x24(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdx
leaq 0x1c081(%rip), %rdi     # 0x24cc8
addq $0x10d0, %rdi           # imm = 0x10D0
callq 0x6350
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl 0x4(%rcx), %edx
addl $0x1, %edx
movl %edx, 0x4(%rcx)
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl $0x0, 0x10(%rcx)
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8cbd
jmp 0x8c96
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8c0f
leaq 0x1c01d(%rip), %rax     # 0x24cc8
movl $0x17, 0x10c8(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x8da8
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jg 0x8d77
movq -0x10(%rbp), %rdi
callq 0x8700
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x0, 0x4(%rcx)
movq 0x1db0(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x7a80
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x32c0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x8540
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0x14(%rbp), %esi
callq 0x8fe0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x8f15
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8fd1
movq -0x40(%rbp), %rdi
callq 0x9050
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x8f67
movq 0xb097(%rip), %rdi      # 0x13fc8
leaq 0x5123(%rip), %rsi      # 0xe05b
callq 0x32e0
movq %rax, %rdi
movq 0xb069(%rip), %rsi      # 0x13fb0
callq 0x3330
leaq 0x1bd75(%rip), %rax     # 0x24cc8
movl $0x17, 0x10c8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8fd1
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0xb3cb(%rip), %rax      # 0x14350
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %esi
addl $0x2, %esi
leaq 0xb3b0(%rip), %rdi      # 0x14350
callq 0x3f10
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x8940
movq -0x38(%rbp), %rsi
leaq 0xb38c(%rip), %rdi      # 0x14350
callq 0x3e80
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x64, -0x18(%rbp)
jge 0x9041
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x9034
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x9034
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9048
jmp 0x9036
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8ffa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x90a4
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x9097
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x90ac
jmp 0x9099
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9067
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x912a
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x911d
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x32c0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x8540
jmp 0x911f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x90db
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x1038, %rdi           # imm = 0x1038
movq %rdi, -0x38(%rbp)
callq 0x34a0
movq -0x28(%rbp), %rdi
addq $0x10a8, %rdi           # imm = 0x10A8
movq %rdi, -0x30(%rbp)
callq 0x34a0
movq -0x28(%rbp), %rdi
addq $0x10d0, %rdi           # imm = 0x10D0
movq %rdi, -0x20(%rbp)
callq 0x6200
jmp 0x925e
movq -0x28(%rbp), %rdi
addq $0x13f0, %rdi           # imm = 0x13F0
movq %rdi, -0x40(%rbp)
callq 0x6390
jmp 0x9274
movq -0x28(%rbp), %rdi
addq $0x1408, %rdi           # imm = 0x1408
movq %rdi, -0x48(%rbp)
callq 0x34a0
movq -0x28(%rbp), %rdi
movl $0x0, 0x10c8(%rdi)
leaq 0x1ba0b(%rip), %rax     # 0x24ca8
movq %rax, 0x1400(%rdi)
addq $0x1038, %rdi           # imm = 0x1038
leaq 0x4e32(%rip), %rsi      # 0xe0e4
callq 0x3490
jmp 0x92b9
movq -0x28(%rbp), %rdi
addq $0x10a8, %rdi           # imm = 0x10A8
leaq 0x4e19(%rip), %rsi      # 0xe0e4
callq 0x3490
jmp 0x92d2
movq -0x28(%rbp), %rdi
movq 0x1400(%rdi), %rax
movq (%rax), %rax
movq %rax, 0x1058(%rdi)
movq $0x0, 0x1060(%rdi)
addq $0x1020, %rdi           # imm = 0x1020
xorl %esi, %esi
movl $0x14, %edx
callq 0x3190
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x934e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x9345
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3628
movq -0x40(%rbp), %rdi
callq 0x63a0
movq -0x20(%rbp), %rdi
callq 0x6230
movq -0x30(%rbp), %rdi
callq 0x3628
movq -0x38(%rbp), %rdi
callq 0x3628
movq -0x10(%rbp), %rdi
callq 0x3580
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x1408, %rdi           # imm = 0x1408
callq 0x3450
movq -0x10(%rbp), %rax
movq 0x1400(%rax), %rdi
callq 0x7060
movq -0x10(%rbp), %rdi
callq 0x9450
testb $0x1, %al
jne 0x941f
jmp 0x9421
jmp 0x9447
movq -0x10(%rbp), %rsi
addq $0x1408, %rsi           # imm = 0x1408
movq 0xab95(%rip), %rdi      # 0x13fc8
callq 0x32a0
movq %rax, %rdi
movq 0xab6e(%rip), %rsi      # 0x13fb0
callq 0x3330
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x10c8(%rax)
je 0x94b5
movq 0xab54(%rip), %rdi      # 0x13fc8
leaq 0x4db3(%rip), %rsi      # 0xe22e
callq 0x32e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x10c8(%rax), %esi
callq 0x3570
movq -0x18(%rbp), %rdi
movl 0x10c8(%rdi), %esi
callq 0xa7c0
movq -0x18(%rbp), %rax
movl $0x0, 0x10c8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x94b9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3140
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x9570
movb %al, -0x3d(%rbp)
jmp 0x9507
movb -0x3d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x51(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x9521
jmp 0x953a
jmp 0x955d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
jmp 0x9563
movq -0x50(%rbp), %rax
movl $0x4000, 0x1024(%rax)   # imm = 0x4000
movq 0x1400(%rax), %rdi
callq 0x6a30
movq -0x50(%rbp), %rdi
callq 0x9450
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3580
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3140
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x9570
movb %al, -0x3d(%rbp)
jmp 0x9a67
movb -0x3d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x51(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x9a81
jmp 0x9a9a
jmp 0x9ab3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
jmp 0x9ab9
movq -0x50(%rbp), %rax
movq 0x1400(%rax), %rdi
callq 0x7290
movq -0x50(%rbp), %rdi
callq 0x9450
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3140
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x9570
movb %al, -0x69(%rbp)
jmp 0x9b15
movb -0x69(%rbp), %al
xorb $-0x1, %al
movb %al, -0x89(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3628
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x9b35
jmp 0x9b54
jmp 0x9be9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3628
jmp 0x9bf2
movq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3140
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x9c00
movl %eax, -0x90(%rbp)
jmp 0x9b83
leaq -0x68(%rbp), %rdi
callq 0x3628
movl -0x90(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jne 0x9bc7
movq 0xa426(%rip), %rdi      # 0x13fc8
leaq 0x453d(%rip), %rsi      # 0xe0e6
callq 0x32e0
jmp 0x9be9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3628
jmp 0x9bf2
movq -0x80(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, 0x1024(%rax)
movq 0x1400(%rax), %rdi
callq 0x6a30
movq -0x80(%rbp), %rdi
callq 0x9450
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3580
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x45bd(%rip), %rsi      # 0xe1ea
xorl %eax, %eax
movl %eax, %edx
callq 0x3600
cmpq $-0x1, %rax
je 0x9c47
movl -0x14(%rbp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x459b(%rip), %rsi      # 0xe1ed
xorl %eax, %eax
movl %eax, %edx
callq 0x3600
cmpq $-0x1, %rax
je 0x9c6c
movl -0x14(%rbp), %eax
orl $0x80, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x4579(%rip), %rsi      # 0xe1f0
xorl %eax, %eax
movl %eax, %edx
callq 0x3600
cmpq $-0x1, %rax
je 0x9c91
movl -0x14(%rbp), %eax
orl $0x180, %eax            # imm = 0x180
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3140
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x9570
movb %al, -0x3d(%rbp)
jmp 0x9cd7
movb -0x3d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x51(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x9cf1
jmp 0x9d0a
jmp 0x9d23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
jmp 0x9d29
movq -0x50(%rbp), %rax
movq 0x1400(%rax), %rdi
callq 0x6cf0
movq -0x50(%rbp), %rdi
callq 0x9450
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3140
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x9570
movb %al, -0x69(%rbp)
jmp 0x9d85
movb -0x69(%rbp), %al
xorb $-0x1, %al
movb %al, -0x89(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3628
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x9da5
jmp 0x9dc4
jmp 0x9e92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3628
jmp 0x9e9b
movq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3140
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x9eb0
movl %eax, -0x90(%rbp)
jmp 0x9df3
leaq -0x68(%rbp), %rdi
callq 0x3628
movl -0x90(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jne 0x9e37
movq 0xa1b6(%rip), %rdi      # 0x13fc8
leaq 0x42e9(%rip), %rsi      # 0xe102
callq 0x32e0
jmp 0x9e92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3628
jmp 0x9e9b
movq -0x80(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, 0x1024(%rax)
movq 0x1400(%rax), %rdi
callq 0x6420
movq -0x80(%rbp), %rdi
callq 0x9450
testb $0x1, %al
jne 0x9e5f
jmp 0x9e61
jmp 0x9e92
movq 0xa160(%rip), %rdi      # 0x13fc8
leaq 0x42a3(%rip), %rsi      # 0xe112
callq 0x32e0
movq %rax, %rdi
movq -0x80(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3480
movq %rax, %rdi
movq 0xa123(%rip), %rsi      # 0x13fb0
callq 0x3330
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x430d(%rip), %rsi      # 0xe1ea
xorl %eax, %eax
movl %eax, %edx
callq 0x3600
cmpq $-0x1, %rax
je 0x9ef5
movl -0x14(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x42ed(%rip), %rsi      # 0xe1ed
xorl %eax, %eax
movl %eax, %edx
callq 0x3600
cmpq $-0x1, %rax
je 0x9f18
movl -0x14(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x42cd(%rip), %rsi      # 0xe1f0
xorl %eax, %eax
movl %eax, %edx
callq 0x3600
cmpq $-0x1, %rax
je 0x9f3b
movl -0x14(%rbp), %eax
orl $0x3, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x3550
testb $0x1, %al
jne 0x9f96
movq -0x20(%rbp), %rdi
callq 0x30d0
movsbl (%rax), %edi
callq 0x32b0
cmpl $0x0, %eax
jne 0x9fab
movq 0xa02b(%rip), %rdi      # 0x13fc8
leaq 0x418d(%rip), %rsi      # 0xe131
callq 0x32e0
jmp 0x9fde
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xa920
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1020(%rax)
movq 0x1400(%rax), %rdi
callq 0x6c60
movq -0x18(%rbp), %rdi
callq 0x9450
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3550
testb $0x1, %al
jne 0xa046
movq -0x40(%rbp), %rdi
callq 0x30d0
movsbl (%rax), %edi
callq 0x32b0
cmpl $0x0, %eax
jne 0xa05e
movq 0x9f7b(%rip), %rdi      # 0x13fc8
leaq 0x40ee(%rip), %rsi      # 0xe142
callq 0x32e0
jmp 0xa12c
movq -0x38(%rbp), %rdi
callq 0x3550
testb $0x1, %al
jne 0xa06d
jmp 0xa085
movq 0x9f54(%rip), %rdi      # 0x13fc8
leaq 0x40c7(%rip), %rsi      # 0xe142
callq 0x32e0
jmp 0xa12c
movq -0x30(%rbp), %rdi
callq 0x3550
testb $0x1, %al
jne 0xa0a8
movq -0x30(%rbp), %rdi
callq 0x30d0
movsbl (%rax), %edi
callq 0x32b0
cmpl $0x0, %eax
jne 0xa0bd
movq 0x9f19(%rip), %rdi      # 0x13fc8
leaq 0x408c(%rip), %rsi      # 0xe142
callq 0x32e0
jmp 0xa12c
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xa920
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x1020(%rax)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xa920
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x1024(%rax)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xa920
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x1028(%rax)
movq 0x1400(%rax), %rdi
callq 0x6e00
movq -0x28(%rbp), %rdi
callq 0x9450
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34a0
movl -0xc(%rbp), %eax
movq %rax, -0x48(%rbp)
subq $0x1c, %rax
ja 0xa8d1
movq -0x48(%rbp), %rax
leaq 0x387c(%rip), %rcx      # 0xe070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3a33(%rip), %rsi      # 0xe237
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa80f
jmp 0xa8d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3628
jmp 0xa90a
leaq 0x3a0f(%rip), %rsi      # 0xe244
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa840
jmp 0xa8d3
leaq 0x3a14(%rip), %rsi      # 0xe260
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa857
jmp 0xa8d3
leaq 0x3a12(%rip), %rsi      # 0xe272
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa86b
jmp 0xa8d3
leaq 0x3a12(%rip), %rsi      # 0xe286
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa87f
jmp 0xa8d3
leaq 0x3a10(%rip), %rsi      # 0xe298
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa893
jmp 0xa8d3
leaq 0x3a12(%rip), %rsi      # 0xe2ae
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa8a7
jmp 0xa8d3
leaq 0x3a14(%rip), %rsi      # 0xe2c4
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa8bb
jmp 0xa8d3
leaq 0x3a11(%rip), %rsi      # 0xe2d5
leaq -0x30(%rbp), %rdi
callq 0x3490
jmp 0xa8cf
jmp 0xa8d3
jmp 0xa8d3
movq 0x96ee(%rip), %rdi      # 0x13fc8
leaq -0x30(%rbp), %rsi
callq 0x32a0
movq %rax, -0x50(%rbp)
jmp 0xa8e9
movq -0x50(%rbp), %rdi
movq 0x96bc(%rip), %rsi      # 0x13fb0
callq 0x3330
jmp 0xa8fb
leaq -0x30(%rbp), %rdi
callq 0x3628
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x220, %rsp            # imm = 0x220
movq %rsi, -0x1f0(%rbp)
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xb930
movq -0x1e0(%rbp), %rdi
callq 0xb950
movl $0x10, %edi
movl $0x8, %esi
callq 0xa960
movl %eax, -0x1d8(%rbp)
jmp 0xac67
movl -0x1d8(%rbp), %edx
movq -0x1f0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x3510
jmp 0xac82
leaq -0x1d0(%rbp), %rdi
callq 0x34a0
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x3410
movq %rax, -0x1f8(%rbp)
jmp 0xacaa
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33f0
movb %al, -0x1f9(%rbp)
jmp 0xacc8
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0xacd4
jmp 0xad31
movq -0x1e0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xb970
jmp 0xace9
jmp 0xac8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0xae4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3628
leaq -0x1a0(%rbp), %rdi
callq 0x3230
jmp 0xae4b
leaq 0x9609(%rip), %rax      # 0x14341
testb $0x1, (%rax)
je 0xae0d
movq 0x9280(%rip), %rdi      # 0x13fc8
leaq 0x35a5(%rip), %rsi      # 0xe2f4
callq 0x32e0
movq %rax, -0x208(%rbp)
jmp 0xad5d
movq -0x208(%rbp), %rdi
movq 0x9245(%rip), %rsi      # 0x13fb0
callq 0x3330
jmp 0xad72
movl $0x0, -0x1d4(%rbp)
movq -0x1e0(%rbp), %rdi
movslq -0x1d4(%rbp), %rax
movq %rax, -0x210(%rbp)
callq 0xb9e0
movq %rax, %rcx
movq -0x210(%rbp), %rax
cmpq %rcx, %rax
jae 0xadf6
movq -0x1e0(%rbp), %rdi
movslq -0x1d4(%rbp), %rsi
callq 0xba00
movq %rax, %rsi
movq 0x9206(%rip), %rdi      # 0x13fc8
callq 0x32a0
movq %rax, -0x218(%rbp)
jmp 0xadd0
movq -0x218(%rbp), %rdi
movl $0x20, %esi
callq 0x3390
jmp 0xade3
jmp 0xade5
movl -0x1d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4(%rbp)
jmp 0xad7c
movq 0x91cb(%rip), %rdi      # 0x13fc8
movq 0x91ac(%rip), %rsi      # 0x13fb0
callq 0x3330
jmp 0xae0b
jmp 0xae0d
movb $0x1, -0x11(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3628
leaq -0x1a0(%rbp), %rdi
callq 0x3230
testb $0x1, -0x11(%rbp)
jne 0xae3b
movq -0x1e0(%rbp), %rdi
callq 0xba20
movq -0x1e8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1e0(%rbp), %rdi
callq 0xba20
movq -0x1a8(%rbp), %rdi
callq 0x3580
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movb $0x0, 0x7958(%rip)      # 0x14341
leaq 0x19ca(%rip), %rsi      # 0xe3ba
leaq 0x19379(%rip), %rdx     # 0x25d70
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xcba0
movq -0xb0(%rbp), %rsi
leaq 0x19ba(%rip), %rdx      # 0xe3cf
leaq -0x28(%rbp), %rdi
callq 0xcb50
jmp 0xca20
movq 0x75a1(%rip), %rdi      # 0x13fc8
leaq -0x28(%rbp), %rsi
callq 0x32a0
jmp 0xca32
leaq -0x28(%rbp), %rdi
callq 0x3628
leaq -0x48(%rbp), %rdi
callq 0x3628
movq 0x7595(%rip), %rdi      # 0x13fe0
leaq 0x1969e(%rip), %rsi     # 0x260f0
movq %rsi, -0xc0(%rbp)
callq 0x30a0
movq -0xc0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3140
movq -0xb8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xac10
jmp 0xca8a
leaq -0x90(%rbp), %rdi
callq 0x3628
leaq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xccb0
jmp 0xcaa8
leaq -0xa8(%rbp), %rdi
callq 0xae70
jmp 0xcab6
leaq -0xa8(%rbp), %rdi
callq 0xba20
leaq -0x70(%rbp), %rdi
callq 0xba20
jmp 0xc9e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xcaf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3628
leaq -0x48(%rbp), %rdi
callq 0x3628
jmp 0xcb47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3628
jmp 0xcb47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xcb3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xba20
leaq -0x70(%rbp), %rdi
callq 0xba20
movq -0x50(%rbp), %rdi
callq 0x3580
// File: 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
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x50(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x3370
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c4c
movq -0x50(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3440
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x3c3c
movq -0x50(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x3370
movq -0x60(%rbp), %rdx
movq -0x50(%rbp), %rsi
movq %rax, %rcx
movslq -0x14(%rbp), %rax
subq %rax, %rcx
leaq -0x38(%rbp), %rdi
callq 0x3250
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x32c0
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x3c4c
jmp 0x3c3e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3bc6
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x240, %rsp            # imm = 0x240
leaq -0x200(%rbp), %rdi
leaq 0x937d(%rip), %rsi      # 0xd066
movl $0x10, %edx
callq 0x3290
movl $0x0, -0x204(%rbp)
movslq -0x204(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq 0xe5ae(%rip), %rdi      # 0x122c0
callq 0x9100
movq %rax, %rcx
movq -0x220(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3e39
movslq -0x204(%rbp), %rsi
leaq 0xe584(%rip), %rdi      # 0x122c0
callq 0x9120
movq %rax, %rsi
leaq -0x200(%rbp), %rdi
callq 0x3200
movq %rax, -0x228(%rbp)
jmp 0x3d59
movq -0x228(%rbp), %rdi
leaq 0x92b7(%rip), %rsi      # 0xd01e
callq 0x3220
jmp 0x3d6e
cmpl $0x0, -0x204(%rbp)
jne 0x3e23
movl $0x0, -0x218(%rbp)
movslq -0x218(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq 0xe53e(%rip), %rdi      # 0x122d8
callq 0x9100
movq %rax, %rcx
movq -0x230(%rbp), %rax
cmpq %rcx, %rax
jae 0x3e21
movslq -0x218(%rbp), %rsi
leaq 0xe51c(%rip), %rdi      # 0x122d8
callq 0x9120
movq %rax, %rsi
leaq -0x200(%rbp), %rdi
callq 0x3200
movq %rax, -0x238(%rbp)
jmp 0x3dd9
movq -0x238(%rbp), %rdi
leaq 0x9237(%rip), %rsi      # 0xd01e
callq 0x3220
jmp 0x3dee
jmp 0x3df0
movl -0x218(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x218(%rbp)
jmp 0x3d85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x3360
jmp 0x3e4e
jmp 0x3e23
jmp 0x3e25
movl -0x204(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x204(%rbp)
jmp 0x3cfd
leaq -0x200(%rbp), %rdi
callq 0x3360
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)