LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_bsm_benchmark.cpp
// Function: double call_bsm_model<double>(double, double, double, double, double)
inline T call_bsm_model(T s, T k, T t, T r, T v)
{
   using namespace std;
   using namespace exprtk::details::numeric;

   const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
   const T d2 = d1 - v * sqrt(t);
   return s * ncdf(d1) - k * exp(-r * t) * ncdf(d2);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm4, 0x10(%rsp)
movaps %xmm3, 0x30(%rsp)
movsd %xmm2, (%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
divsd %xmm1, %xmm0
callq 0x1140f0
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x18a688(%rip), %xmm1   # 0x2a3028
addsd 0x30(%rsp), %xmm1
movsd (%rsp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
xorps %xmm2, %xmm2
sqrtsd %xmm3, %xmm2
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
movapd %xmm2, %xmm0
jae 0x1189ee
movsd (%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x114230
xorpd %xmm4, %xmm4
movsd 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm4, %xmm0
jae 0x118a1d
movsd (%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x114230
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
divsd 0x18a5f3(%rip), %xmm1   # 0x2a3030
movapd %xmm1, %xmm0
callq 0x1143f0
mulsd 0x18a5da(%rip), %xmm0   # 0x2a3028
movsd %xmm0, 0x10(%rsp)
movapd 0x30(%rsp), %xmm0
xorpd 0x18a6ae(%rip), %xmm0   # 0x2a3110
mulsd (%rsp), %xmm0
callq 0x1140b0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
divsd 0x18a5b1(%rip), %xmm0   # 0x2a3030
callq 0x1143f0
mulsd 0x18a59c(%rip), %xmm0   # 0x2a3028
movsd (%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_bsm_benchmark.cpp
// Function: double put_bsm_model<double>(double, double, double, double, double)
inline T put_bsm_model(T s, T k, T t, T r, T v)
{
   using namespace std;
   using namespace exprtk::details::numeric;

   const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
   const T d2 = d1 - v * sqrt(t);
   return k * exp(-r * t) * ncdf(-d2) - s * ncdf(-d1);
}

// Assembly:
subq $0x48, %rsp
movsd %xmm4, 0x8(%rsp)
movaps %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
divsd %xmm1, %xmm0
callq 0x1140f0
movsd 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x18a536(%rip), %xmm1   # 0x2a3028
addsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm3, %xmm3
sqrtsd %xmm2, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm2
movapd %xmm3, %xmm0
jae 0x118b40
movapd %xmm2, %xmm0
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x30(%rsp)
callq 0x114230
xorpd %xmm4, %xmm4
movsd 0x30(%rsp), %xmm3
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
divsd %xmm0, %xmm1
ucomisd %xmm4, %xmm2
movsd %xmm1, 0x10(%rsp)
jae 0x118b6f
movapd %xmm2, %xmm0
callq 0x114230
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x8(%rsp), %xmm0
mulsd %xmm3, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd 0x20(%rsp), %xmm0
xorpd 0x18a57f(%rip), %xmm0   # 0x2a3110
mulsd %xmm2, %xmm0
callq 0x1140b0
mulsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
divsd 0x18a484(%rip), %xmm0   # 0x2a3038
callq 0x1143f0
mulsd 0x18a467(%rip), %xmm0   # 0x2a3028
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
divsd 0x18a45d(%rip), %xmm0   # 0x2a3038
callq 0x1143f0
mulsd 0x18a458(%rip), %xmm0   # 0x2a3040
mulsd 0x40(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_bsm_benchmark.cpp
// Function: double bsm_model<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, double, double, double, double)
inline T bsm_model(const std::string& callput_flag, const T s, const T k, const T t, const T r, const T v)
{
   using namespace std;
   using namespace exprtk::details::numeric;

   const T d1 = (log(s / k) + (r + (v * v) / 2) * t) / (v * sqrt(t));
   const T d2 = d1 - v * sqrt(t);

   if (callput_flag == "call")
      return s * ncdf(d1) - k * exp(-r * t) * ncdf(d2);
   else if (callput_flag == "put")
      return k * exp(-r * t) * ncdf(-d2) - s * ncdf(-d1);
   else
      return T(0);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movsd %xmm4, 0x10(%rsp)
movaps %xmm3, 0x30(%rsp)
movsd %xmm2, 0x8(%rsp)
movq %rdi, %rbx
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
divsd %xmm1, %xmm0
callq 0x1140f0
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm1
mulsd 0xc53(%rip), %xmm1      # 0x2a3028
addsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm3, %xmm3
sqrtsd %xmm2, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm2
movapd %xmm3, %xmm0
jae 0x2a2423
movapd %xmm2, %xmm0
movsd %xmm1, 0x18(%rsp)
movsd %xmm3, 0x48(%rsp)
callq 0x114230
xorpd %xmm4, %xmm4
movsd 0x48(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
divsd %xmm0, %xmm1
ucomisd %xmm4, %xmm2
movsd %xmm1, 0x18(%rsp)
jae 0x2a244e
movsd 0x8(%rsp), %xmm0
callq 0x114230
movsd 0x18(%rsp), %xmm1
movapd %xmm0, %xmm3
movsd 0x10(%rsp), %xmm0
mulsd %xmm3, %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
leaq 0x9690(%rip), %rsi      # 0x2abafd
movq %rbx, %rdi
callq 0x114460
testl %eax, %eax
je 0x2a2499
leaq 0x5ca9(%rip), %rsi      # 0x2a8129
movq %rbx, %rdi
callq 0x114460
testl %eax, %eax
je 0x2a2516
xorpd %xmm0, %xmm0
jmp 0x2a2589
movsd 0x18(%rsp), %xmm0
divsd 0xb89(%rip), %xmm0      # 0x2a3030
callq 0x1143f0
mulsd 0xb74(%rip), %xmm0      # 0x2a3028
movsd %xmm0, 0x18(%rsp)
movapd 0x30(%rsp), %xmm0
xorpd 0xc48(%rip), %xmm0      # 0x2a3110
mulsd 0x8(%rsp), %xmm0
callq 0x1140b0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
divsd 0xb49(%rip), %xmm0      # 0x2a3030
callq 0x1143f0
mulsd 0xb34(%rip), %xmm0      # 0x2a3028
movsd 0x8(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
jmp 0x2a2589
movapd 0x30(%rsp), %xmm0
xorpd 0xbec(%rip), %xmm0      # 0x2a3110
mulsd 0x8(%rsp), %xmm0
callq 0x1140b0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
divsd 0xaef(%rip), %xmm0      # 0x2a3038
callq 0x1143f0
mulsd 0xad2(%rip), %xmm0      # 0x2a3028
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
divsd 0xac8(%rip), %xmm0      # 0x2a3038
callq 0x1143f0
mulsd 0xac3(%rip), %xmm0      # 0x2a3040
mulsd 0x28(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Initialize()
void BufferManager::Initialize()
{
	for (int i = 0; i < NBUF; ++i) 
	{
		if (i) 
		{
			m_Buf[i].b_forw = m_Buf + i - 1;
		}
		else 
		{
			m_Buf[i].b_forw = bFreeList;
			bFreeList->b_back = m_Buf + i;
		}

		if (i + 1 < NBUF) 
		{
			m_Buf[i].b_back = m_Buf + i + 1;
		}
		else 
		{
			m_Buf[i].b_back = bFreeList;
			bFreeList->b_forw = m_Buf + i;
		}
		m_Buf[i].b_addr = Buffer[i];
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq 0x15e8(%rdi), %rax
leaq 0x8(%rdi), %rcx
leaq -0x30(%rdi), %rsi
movq (%rdi), %rdx
leaq 0x40(%rdi), %r8
xorl %r9d, %r9d
testl %r9d, %r9d
je 0x38b7
movl %r9d, %r10d
imulq $0x38, %r10, %r11
leaq (%rsi,%r11), %rbx
movq %rbx, 0x8(%rcx,%r11)
cmpl $0x63, %r9d
jne 0x38c2
jmp 0x38e0
movq %rdx, 0x10(%rdi)
movq %rcx, 0x10(%rdx)
xorl %r10d, %r10d
imulq $0x38, %r10, %r11
leaq (%r8,%r11), %rbx
movq %rbx, 0x10(%rcx,%r11)
shlq $0x9, %r10
addq %rax, %r10
movq %r10, 0x20(%rcx,%r11)
incl %r9d
jmp 0x389a
movq %rdx, 0x15c0(%rdi)
addq $0x15b0, %rdi           # imm = 0x15B0
movq %rdi, 0x8(%rdx)
shlq $0x9, %r10
addq %r10, %rax
movq %rax, 0x20(%rcx,%r11)
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::GetBlk(int)
Buf* BufferManager::GetBlk(int blkno)
{
	Buf* bp;
	// User& u = globalUser;

	if (m_map.find(blkno) != m_map.end())
	{
		bp = m_map[blkno];
		Bdetach(bp);
		return bp;
	}

	// �����������ɶ���
	bp = bFreeList->b_back;
	if (bp == bFreeList)
	{
		cout << "bFreeList���в���" << endl;
		return NULL;
	}

	Bdetach(bp);
	m_map.erase(bp->b_blkno);

	if (bp->b_flags & Buf::B_DELWRI) {
		m_DeviceManager->write(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);
	}

	bp->b_flags &= ~(Buf::B_DELWRI | Buf::B_DONE);
	bp->b_blkno = blkno;
	m_map[blkno] = bp;

	return bp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq -0x1c(%rbp), %rax
movl %esi, (%rax)
leaq 0xddf0(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3e22
testq %rax, %rax
je 0x3964
leaq -0x1c(%rbp), %rsi
movq %r14, %rdi
callq 0x3e84
movq (%rax), %rbx
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3a23
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rbx), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x3a23
movq (%r15), %rax
movq 0x10(%rax), %rbx
cmpq %rax, %rbx
je 0x39df
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3990
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rbx), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x414c
movl (%rbx), %eax
testb %al, %al
jns 0x39c2
movq 0xdde8(%r15), %rdi
movq 0x20(%rbx), %rsi
movl 0x28(%rbx), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x42da
movl (%rbx), %eax
andl $0xffffff7b, %eax       # imm = 0xFFFFFF7B
movl %eax, (%rbx)
leaq -0x1c(%rbp), %rsi
movl (%rsi), %eax
movl %eax, 0x28(%rbx)
movq %r14, %rdi
callq 0x3e84
movq %rbx, (%rax)
jmp 0x3a23
movq 0x95e2(%rip), %rbx      # 0xcfc8
leaq 0x5617(%rip), %rsi      # 0x9004
movl $0x11, %edx
movq %rbx, %rdi
callq 0x3260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bdetach(Buf*)
void BufferManager::Bdetach(Buf *bp)
{
	if (bp->b_back == NULL) {
		return;
	}

	bp->b_forw->b_back = bp->b_back;
	bp->b_back->b_forw = bp->b_forw;

	bp->b_back = NULL;
	bp->b_forw = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x3a56
movq 0x8(%rsi), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rsi), %rax
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Brelse(Buf*)
void BufferManager::Binsert(Buf* bp)
{
	if (bp->b_back != NULL) {
		return;
	}

	bp->b_forw = bFreeList->b_forw;
	bp->b_back = bFreeList;

	bFreeList->b_forw->b_back = bp;
	bFreeList->b_forw = bp;
}

// Assembly:
cmpq $0x0, 0x10(%rsi)
je 0x3a60
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bread(int)
Buf* BufferManager::Bread(int blkno)
{
	Buf* bp;
	bp = this->GetBlk(blkno);
	if (bp->b_flags & (Buf::B_DONE | Buf::B_DELWRI))
	{
		return bp;
	}

	m_DeviceManager->read(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);

	bp->b_flags |= Buf::B_DONE;
	
	return bp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x3902
movq %rax, %rbx
testb $-0x7c, (%rax)
jne 0x3adc
movq 0xdde8(%r14), %rdi
movq 0x20(%rbx), %rsi
movl 0x28(%rbx), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x431c
orb $0x4, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bwrite(Buf*)
void BufferManager::Bwrite(Buf* bp)
{
	bp->b_flags &= ~(Buf::B_DELWRI);
	m_DeviceManager->write(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);
	bp->b_flags |= Buf::B_DONE;
	Brelse(bp);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
andb $0x7f, (%rsi)
movq 0xdde8(%rdi), %rdi
movq 0x20(%rsi), %rsi
movl 0x28(%rbx), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x42da
orb $0x4, (%rbx)
cmpq $0x0, 0x10(%rbx)
jne 0x3b33
movq (%r14), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, 0x10(%rcx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bdwrite(Buf*)
void BufferManager::Bdwrite(Buf* bp)
{
	/* ����B_DONE������������ʹ�øô��̿����� */
	bp->b_flags |= (Buf::B_DELWRI | Buf::B_DONE);
	this->Brelse(bp);
	return;
}

// Assembly:
orb $-0x7c, (%rsi)
cmpq $0x0, 0x10(%rsi)
je 0x3ba5
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/BufferManager.cpp
// Function: BufferManager::Bflush()
void BufferManager::Bflush()
{
	Buf* bp = NULL;

	for (int cnt = 0; cnt < NBUF; cnt++) 
	{
		bp = m_Buf + cnt;
		if (bp->b_flags & Buf::B_DELWRI) {
			bp->b_flags &= ~(Buf::B_DELWRI);
			m_DeviceManager->write(bp->b_addr, BUFFER_SIZE, bp->b_blkno * BUFFER_SIZE);
			bp->b_flags |= (Buf::B_DONE);
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movl 0x8(%rbx,%r14), %eax
testb %al, %al
jns 0x3c1f
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movl %eax, 0x8(%rbx,%r14)
movq 0xdde8(%rbx), %rdi
movq 0x28(%rbx,%r14), %rsi
movl 0x30(%rbx,%r14), %ecx
shll $0x9, %ecx
movl $0x200, %edx            # imm = 0x200
xorl %r8d, %r8d
callq 0x42da
orb $0x4, 0x8(%rbx,%r14)
addq $0x38, %r14
cmpq $0x15e0, %r14           # imm = 0x15E0
jne 0x3be5
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/DeviceManager.cpp
// Function: DeviceManager::Construct()
void DeviceManager::Construct() {
    fp = fopen(DISK_FILE_NAME, "wb+");
    if (fp == NULL) {
        printf("�򿪻��½��ļ�%sʧ�ܣ�", DISK_FILE_NAME);
        exit(-1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8f98(%rip), %rdi      # 0xd238
leaq 0x4d7a(%rip), %rsi      # 0x9021
callq 0x3270
movq %rax, (%rbx)
testq %rax, %rax
je 0x42bb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8f76(%rip), %rsi      # 0xd238
leaq 0x4d5c(%rip), %rdi      # 0x9025
xorl %eax, %eax
callq 0x3060
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::FileManager()
FileManager::FileManager() 
{
    m_FileSystem = &globalFileSystem;
    m_OpenFileTable = &globalOpenFileTable;
    m_InodeTable = &globalINodeTable;
    rootDirInode = m_InodeTable->IGet(0);
    rootDirInode->i_count += 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x179bc(%rip), %rax     # 0x1bde8
movq %rax, 0x8(%rdi)
leaq 0x16c51(%rip), %rax     # 0x1b088
movq %rax, 0x18(%rdi)
leaq 0x179be(%rip), %rdi     # 0x1be00
movq %rdi, 0x10(%rbx)
xorl %esi, %esi
callq 0x5eae
movq %rax, (%rbx)
addl $0xff, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Open1(Inode*, int, int)
void FileManager::Open1(Inode* pINode, int mode, int trf) 
{
    User& u = globalUser;

    /* ��creat�ļ���ʱ��������ͬ�ļ������ļ����ͷŸ��ļ���ռ�ݵ������̿� */
    if (1 == trf) 
    {
        pINode->ITrunc();
    }

    /* ���������ļ����ƿ�File�ṹ */
    File* pFile = this->m_OpenFileTable->FAlloc();
    if (NULL == pFile) 
    {
        this->m_InodeTable->IPut(pINode);
        return;
    }

    /* ���ô����ļ���ʽ������File�ṹ���ڴ�Inode�Ĺ�����ϵ */
    pFile->f_flag = mode & (File::FREAD | File::FWRITE);
    pFile->f_inode = pINode;

    /* Ϊ�򿪻��ߴ����ļ��ĸ�����Դ���ѳɹ����䣬�������� */
    if (u.u_error == 0) 
    {
        return;
    }
    else {  /* �����������ͷ���Դ */
        /* �ͷŴ����ļ������� */
        int fd = u.u_ar0[User::EAX];
        if (fd != -1) 
        {
            u.u_ofiles.SetF(fd, NULL);
            /* �ݼ�File�ṹ��Inode�����ü��� ,File�ṹû���� f_countΪ0�����ͷ�File�ṹ��*/
            pFile->f_count--;
        }
        this->m_InodeTable->IPut(pINode);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %ecx
jne 0x47c9
movq %rbx, %rdi
callq 0x5aa2
movq 0x18(%r14), %rdi
callq 0x5d14
testq %rax, %rax
je 0x4814
movq %rax, %r15
andl $0x3, %r12d
movl %r12d, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x193ec(%rip), %rax     # 0x1dbd8
cmpl $0x0, 0x10c8(%rax)
je 0x4828
movl 0x20(%rax), %esi
cmpl $-0x1, %esi
je 0x4814
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x87c7(%rip), %rdi      # 0xcfd0
xorl %edx, %edx
callq 0x43fe
decl 0x4(%r15)
movq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5dc0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Creat()
void FileManager::Creat() 
{
    Inode* pINode;
    User& u = globalUser;
    unsigned int newACCMode = u.u_arg[1];

    /* ����Ŀ¼��ģʽΪ1����ʾ����������Ŀ¼����д���������� */
    pINode = this->NameI(FileManager::CREATE);

    /* û���ҵ���Ӧ��Inode����NameI���� */
    if (NULL == pINode) 
    {
        if (u.u_error)
            return;
        pINode = this->MakNode(newACCMode);
        if (NULL == pINode)
            return;

        /*
         * ������ϣ�������ֲ����ڣ�ʹ�ò���trf = 2������open1()��
         * ����Ҫ����Ȩ�޼��飬��Ϊ�ոս������ļ���Ȩ�޺ʹ�������mode
         * ����ʾ��Ȩ��������һ���ġ�
         */
        this->Open1(pINode, File::FWRITE, 2);
        return;
    }

    /* ����NameI()�������Ѿ�����Ҫ�������ļ��������ո��ļ������㷨ITrunc()����UIDû�иı�
     * ԭ��UNIX���������������ļ�����ȥ�����½����ļ�һ����Ȼ�������ļ������ߺ�����Ȩ��ʽû�䡣
     * Ҳ����˵creatָ����RWX������Ч��
     * ������Ϊ���ǲ������ģ�Ӧ�øı䡣
     * ���ڵ�ʵ�֣�creatָ����RWX������Ч */
    this->Open1(pINode, File::FWRITE, 1);
    pINode->i_mode |= newACCMode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x19391(%rip), %r12     # 0x1dbd8
movl 0x1024(%r12), %r14d
movl $0x1, %esi
callq 0x44a0
testq %rax, %rax
je 0x487c
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x47a8
orl %r14d, 0x4(%r15)
jmp 0x4887
cmpl $0x0, 0x10c8(%r12)
je 0x4890
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
callq 0x48be
testq %rax, %rax
je 0x4887
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
movl $0x2, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x47a8
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::MakNode(unsigned int)
Inode* FileManager::MakNode(unsigned int mode) 
{
    Inode* pINode;
    User& u = globalUser;

    /* ����һ������DiskInode������������ȫ������ */
    pINode = this->m_FileSystem->IAlloc();
    if (NULL == pINode) 
    {
        return NULL;
    }

    pINode->i_flag |= (Inode::IACC | Inode::IUPD);
    pINode->i_mode = mode | Inode::IALLOC;
    pINode->i_nlink = 1;

    /* ��Ŀ¼��д��u.u_u_dent������д��Ŀ¼�ļ� */
    this->WriteDir(pINode);
    return pINode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x51be
movq %rax, %r14
testq %rax, %rax
je 0x4901
orb $0x6, (%r14)
orl $0x8000, %r15d          # imm = 0x8000
movl %r15d, 0x4(%r14)
movl $0x1, 0xc(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4910
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::WriteDir(Inode*)
void FileManager::WriteDir(Inode* pINode) 
{
    User& u = globalUser;

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x19240(%rip), %rdi     # 0x1dbd8
movl 0x1020(%rdi), %r14d
addq $0x10d0, %rdi           # imm = 0x10D0
movl %r14d, %esi
callq 0x43d4
testq %rax, %rax
je 0x49e2
movq %rax, %r15
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x860e(%rip), %rdi      # 0xcfd0
movl %r14d, %esi
xorl %edx, %edx
callq 0x43fe
movq 0x18(%rbx), %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5d9a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::UnLink()
void FileManager::UnLink() 
{
    Inode* pINode;
    Inode* pDeleteINode;
    User& u = globalUser;

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x2, %esi
callq 0x44a0
testq %rax, %rax
je 0x4a93
movq %rax, %r14
movq 0x10(%rbx), %rdi
leaq 0x191bb(%rip), %r12     # 0x1dbd8
movl 0x1068(%r12), %esi
callq 0x5eae
testq %rax, %rax
je 0x4a93
movq %rax, %r15
addl $-0x20, 0x13f8(%r12)
leaq 0x1068(%r12), %rax
movq %rax, 0x13f0(%r12)
movl $0x20, 0x13fc(%r12)
movl $0x0, 0x1068(%r12)
movq %r14, %rdi
callq 0x588c
decl 0xc(%r15)
orb $0x2, (%r15)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x5dc0
movq 0x10(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5dc0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Seek()
void FileManager::Seek() 
{
    File* pFile;
    User& u = globalUser;
    int fd = u.u_arg[0];

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

    int m_Offset = u.u_arg[1];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1912e(%rip), %r14     # 0x1dbd8
movl 0x1020(%r14), %esi
leaq 0x10d0(%r14), %rdi
callq 0x43d4
testq %rax, %rax
je 0x4b2f
movl 0x1024(%r14), %ecx
movl 0x1028(%r14), %edx
cmpl $0x2, %edx
je 0x4b25
cmpl $0x1, %edx
je 0x4b20
testl %edx, %edx
je 0x4b2c
movq 0x84e3(%rip), %rbx      # 0xcfc8
leaq 0x4550(%rip), %rsi      # 0x903c
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3260
movl 0x1028(%r14), %esi
movq %rbx, %rdi
callq 0x33c0
leaq 0x464f(%rip), %rsi      # 0x915e
movl $0xc, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3260
addl %ecx, 0x10(%rax)
jmp 0x4b2f
movq 0x8(%rax), %rdx
addl 0x1c(%rdx), %ecx
movl %ecx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::Rdwr(File::FileFlags)
void FileManager::Rdwr(enum File::FileFlags mode) 
{
    File* pFile;
    User& u = globalUser;

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
leaq 0x19080(%rip), %r15     # 0x1dbd8
movl 0x1020(%r15), %esi
leaq 0x10d0(%r15), %rdi
callq 0x43d4
testq %rax, %rax
je 0x4be1
movq %rax, %rbx
testl %r14d, (%rax)
je 0x4baf
movslq 0x1024(%r15), %rax
movq %rax, 0x13f0(%r15)
movl 0x1028(%r15), %eax
movl %eax, 0x13fc(%r15)
movl 0x10(%rbx), %eax
movl %eax, 0x13f8(%r15)
movq 0x8(%rbx), %rdi
cmpl $0x1, %r14d
jne 0x4bbc
callq 0x5546
jmp 0x4bc1
movl $0xd, 0x10c8(%r15)
jmp 0x4be1
callq 0x588c
movl 0x1028(%r15), %eax
movl 0x13fc(%r15), %ecx
subl %ecx, %eax
addl %eax, 0x10(%rbx)
movl 0x1028(%r15), %eax
subl %ecx, %eax
movl %eax, 0x20(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/FileManager.cpp
// Function: FileManager::ChDir()
void FileManager::ChDir() 
{
    Inode* pINode;
    User& u = globalUser;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x44a0
testq %rax, %rax
je 0x4e45
movl $0x6000, %ecx           # imm = 0x6000
andl 0x4(%rax), %ecx
cmpl $0x4000, %ecx           # imm = 0x4000
jne 0x4dfa
leaq 0x18e06(%rip), %rbx     # 0x1dbd8
movq %rax, 0x1058(%rbx)
movq 0x1038(%rbx), %rsi
cmpb $0x2f, (%rsi)
jne 0x4e1d
leaq 0x10a8(%rbx), %rdi
leaq 0x1038(%rbx), %rsi
callq 0x3130
jmp 0x4e30
leaq 0x18dd7(%rip), %rcx     # 0x1dbd8
movl $0x14, 0x10c8(%rcx)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5dc0
movq 0x1040(%rbx), %rdx
leaq 0x10a8(%rbx), %rdi
callq 0x30c0
movq 0x10a8(%rbx), %rax
movq 0x10b0(%rbx), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
jne 0x4e4c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x10a8, %edi           # imm = 0x10A8
addq 0x8178(%rip), %rdi      # 0xcfd0
movl $0x2f, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x83d4(%rip), %rdi      # 0xd258
movq %rdi, 0x10(%rbx)
leaq 0x16b59(%rip), %rax     # 0x1b9e8
movq %rax, 0x8(%rbx)
leaq 0x83c6(%rip), %rax      # 0xd260
movq %rax, (%rbx)
callq 0x4282
testb %al, %al
je 0x4ec3
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x431c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4ed2
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl $0x0, 0x338(%rax)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x31e0
movq 0x8(%rbx), %rcx
movl %eax, 0x340(%rcx)
movb $0x1, %r12b
movq %r14, %r15
shlq $0x9, %r15
addq 0x8(%rbx), %r15
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x3902
movq %rax, %r14
movq 0x20(%rax), %rdi
movl $0x200, %edx            # imm = 0x200
movq %r15, %rsi
callq 0x31b0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3ae4
movl $0x1, %r14d
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x515b
leaq 0x16c57(%rip), %rdi     # 0x1be00
callq 0x5ff4
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3bd8
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5423
movq %rdi, %rbx
cmpl $0x1, %ecx
jg 0x53f5
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x3aa4
movq %rax, %r15
movq 0x20(%rax), %rsi
movl (%rsi), %eax
addq $0x4, %rsi
movq 0x8(%rbx), %rdi
movl %eax, 0x8(%rdi)
addq $0xc, %rdi
movl $0x190, %edx            # imm = 0x190
callq 0x31b0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x3a58
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x3902
movq %rax, %r14
testq %rax, %rax
je 0x5413
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3bc2
movq 0x8(%rbx), %rax
movl $0x1, 0x338(%rax)
jmp 0x543e
movl $0x0, 0x8(%rax)
leaq 0x187a7(%rip), %rax     # 0x1dbd8
movl $0x1c, 0x10c8(%rax)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x54b0
movq %rdi, %r14
movq (%rdi), %rdi
movl %ebx, %esi
callq 0x3902
movq %rax, %r15
movq 0x20(%rax), %rdi
movq 0x8(%r14), %rsi
movl 0x8(%rsi), %eax
movl %eax, (%rdi)
addq $0x4, %rdi
addq $0xc, %rsi
movl $0x190, %edx            # imm = 0x190
callq 0x31b0
movq 0x8(%r14), %rax
movl $0x0, 0x8(%rax)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3ae4
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
// File: /workspace/github_cpp_makefile_star2_O3/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:
testb $0x6, (%rdi)
je 0x5aa1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %r15
movl 0x14(%rdi), %eax
leal 0x7(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
sarl $0x3, %esi
addl $0x2, %esi
leaq 0x7872(%rip), %rbx      # 0xd260
movq %rbx, %rdi
callq 0x3aa4
movl 0x4(%r15), %edx
movl 0xc(%r15), %esi
movq 0x18(%r15), %rdi
movups 0x30(%r15), %xmm0
movaps %xmm0, -0x30(%rbp)
movq 0x40(%r15), %rcx
movq %rcx, -0x20(%rbp)
movups 0x20(%r15), %xmm0
movaps %xmm0, -0x40(%rbp)
movl (%r15), %ecx
movl 0x14(%r15), %r9d
movl %ecx, %r8d
shll $0x1d, %r8d
sarl $0x1f, %r8d
andl %r14d, %r8d
shll $0x1e, %ecx
sarl $0x1f, %ecx
andl %r14d, %ecx
movq 0x20(%rax), %r10
leal 0x7(%r9), %r11d
testl %r9d, %r9d
cmovnsl %r9d, %r11d
andl $-0x8, %r11d
subl %r11d, %r9d
movslq %r9d, %r9
shlq $0x6, %r9
movl %edx, (%r10,%r9)
movl %esi, 0x4(%r10,%r9)
movq %rdi, 0x8(%r10,%r9)
movq -0x20(%rbp), %rdx
movq %rdx, 0x30(%r10,%r9)
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movups %xmm1, 0x20(%r10,%r9)
movups %xmm0, 0x10(%r10,%r9)
movl %r8d, 0x38(%r10,%r9)
movl %ecx, 0x3c(%r10,%r9)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3ae4
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/INode.cpp
// Function: Inode::ICopy(Buf*, int)
void Inode::ICopy(Buf* bp, int inumber)
{
	DiskInode& dInode = *(DiskInode*)(bp->b_addr + (inumber % FileSystem::INODE_NUMBER_PER_SECTOR) * sizeof(DiskInode));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rsi), %rax
leal 0x7(%rdx), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
andl $-0x8, %ecx
subl %ecx, %edx
movslq %edx, %rcx
shlq $0x6, %rcx
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
movl (%rax,%rcx,4), %edx
movl %edx, (%rdi,%rcx,4)
incq %rcx
cmpq $0xa, %rcx
jne 0x5c3f
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
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x72a3(%rip), %rdi      # 0xcfd0
callq 0x4392
testl %eax, %eax
js 0x5d5f
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx,%r15)
je 0x5d64
addq $0x18, %r15
cmpq $0x960, %r15            # imm = 0x960
jne 0x5d39
leaq 0x17e83(%rip), %rax     # 0x1dbd8
movl $0x17, 0x10c8(%rax)
xorl %r14d, %r14d
jmp 0x5d8c
leaq (%rbx,%r15), %r14
movl $0x10d0, %edi           # imm = 0x10D0
addq 0x725c(%rip), %rdi      # 0xcfd0
movl %eax, %esi
movq %r14, %rdx
callq 0x43fe
incl 0x4(%rbx,%r15)
movl $0x0, 0x10(%rbx,%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e1a
cmpl $0x0, 0xc(%rbx)
jg 0x5df9
movq %rdi, %r14
movq %rbx, %rdi
callq 0x5aa2
movl $0x0, 0x4(%rbx)
movq 0x1db0(%r14), %rdi
movl 0x14(%rbx), %esi
callq 0x5360
xorl %edi, %edi
callq 0x31e0
movq %rbx, %rdi
movl %eax, %esi
callq 0x59ba
movl $0x0, (%rbx)
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
movl 0x8(%rbx), %eax
decl %eax
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/OpenFileManager.cpp
// Function: InodeTable::IGet(int)
Inode* InodeTable::IGet(int inumber)
{
	Inode* pInode;


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

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

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


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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
xorl %eax, %eax
cmpl %ebx, 0x14(%rdi,%rax)
jne 0x5ece
cmpl $0x0, 0x8(%rdi,%rax)
jne 0x5f91
addq $0x4c, %rax
cmpq $0x1db0, %rax           # imm = 0x1DB0
jne 0x5ebd
xorl %eax, %eax
cmpl $0x0, 0x8(%rdi,%rax)
je 0x5f47
addq $0x4c, %rax
cmpq $0x1db0, %rax           # imm = 0x1DB0
jne 0x5edc
movq 0x70d2(%rip), %rbx      # 0xcfc8
leaq 0x3177(%rip), %rsi      # 0x9074
movl $0x12, %edx
movq %rbx, %rdi
callq 0x3260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
leaq 0x17ca0(%rip), %rax     # 0x1dbd8
movl $0x17, 0x10c8(%rax)
xorl %r14d, %r14d
jmp 0x5f99
leaq (%rdi,%rax), %r14
movl %ebx, 0x14(%rdi,%rax)
movl $0x1, 0x8(%rdi,%rax)
leal 0x7(%rbx), %esi
testl %ebx, %ebx
cmovnsl %ebx, %esi
sarl $0x3, %esi
addl $0x2, %esi
leaq 0x72f4(%rip), %r15      # 0xd260
movq %r15, %rdi
callq 0x3aa4
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x5bf4
movq %r15, %rdi
movq %r12, %rsi
callq 0x3a58
jmp 0x5f99
leaq (%rdi,%rax), %r14
incl 0x8(%rdi,%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::User()
User::User() {
    u_error = myNOERROR;
    u_FileManager = &globalFileManager;
    u_dirp = "/";
    u_curdir = "/";
    //u_FileManager->Open();
    u_cdir = u_FileManager->rootDirInode;
    u_pdir = NULL;
    memset(u_arg, 0, sizeof(u_arg));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
leaq 0x1038(%rdi), %rax
movq %rax, -0x48(%rbp)
leaq 0x1048(%rdi), %rax
movq %rax, -0x40(%rbp)
movq %rax, 0x1038(%rdi)
xorl %eax, %eax
movq %rax, 0x1040(%rdi)
movb %al, 0x1048(%rdi)
leaq 0x10a8(%rdi), %r14
leaq 0x10b8(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, 0x10a8(%rdi)
movq %rax, 0x10b0(%rdi)
movb %al, 0x10b8(%rdi)
leaq 0x10d0(%rdi), %r15
movq %r15, %rdi
callq 0x437a
leaq 0x13f0(%r12), %r13
movq %r13, %rdi
callq 0x4410
leaq 0x1418(%r12), %rbx
movq %rbx, 0x1408(%r12)
movq $0x0, 0x1410(%r12)
movb $0x0, 0x1418(%r12)
movl $0x0, 0x10c8(%r12)
leaq 0x17a33(%rip), %rax     # 0x1dbb8
movq %rax, 0x1400(%r12)
movq 0x1040(%r12), %rdx
leaq 0x2f10(%rip), %rcx      # 0x90ac
movl $0x1, %r8d
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x3370
movq 0x10b0(%r12), %rdx
leaq 0x2ef0(%rip), %rcx      # 0x90ac
movl $0x1, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3370
movq 0x1400(%r12), %rax
movq (%rax), %rax
movq %rax, 0x1058(%r12)
movq $0x0, 0x1060(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x1020(%r12)
movl $0x0, 0x1030(%r12)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
jmp 0x6242
movq %rax, -0x30(%rbp)
jmp 0x624a
movq %rax, -0x30(%rbp)
movq 0x1408(%r12), %rdi
cmpq %rbx, %rdi
je 0x623a
movq (%rbx), %rsi
incq %rsi
callq 0x3220
movq %r13, %rdi
callq 0x4416
movq %r15, %rdi
callq 0x438c
movq (%r14), %rdi
cmpq -0x38(%rbp), %rdi
je 0x6262
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3220
movq -0x48(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0x627e
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3220
movq -0x30(%rbp), %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ljl0222[P]SecondFileSystem/User.cpp
// Function: User::Ls()
void User::Ls() {
    ls.clear();
    u_FileManager->Ls();
    if (IsError()) {
        return;
    }
    cout << ls << endl;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x10c8(%rdi), %r15d
testl %r15d, %r15d
je 0x63ef
movq %rdi, %rbx
movq 0x6c10(%rip), %r14      # 0xcfc8
leaq 0x2e37(%rip), %rsi      # 0x91f6
movl $0x8, %edx
movq %r14, %rdi
callq 0x3260
movl 0x10c8(%rbx), %esi
movq %r14, %rdi
callq 0x33c0
movl 0x10c8(%rbx), %esi
callq 0x75d8
movl $0x0, 0x10c8(%rbx)
testl %r15d, %r15d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq