LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RR_SX::Execute()
void RR_SX::Execute()
{
	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x01 ) != 0 ;

	m_cpu->s[ sX ] >>= 1 ;
	if ( m_cpu->flags.carry )
		m_cpu->s[ sX ] |= 0x80 ;

	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
andb $0x1, %dl
movb %dl, 0x11(%rax)
shrb (%rax,%rcx)
movq 0x8(%rdi), %rax
cmpb $0x1, 0x11(%rax)
jne 0x40a8b0
movzwl 0x10(%rdi), %ecx
orb $-0x80, (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SL0_SX::Execute()
void SL0_SX::Execute()
{
	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x80 ) != 0 ;

	m_cpu->s[ sX ] <<= 1 ;

	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
shrb $0x7, %dl
movb %dl, 0x11(%rax)
shlb (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SLA_SX::Execute()
void SLA_SX::Execute()
{
	bool c ;

	c = m_cpu->flags.carry ;

	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x80 ) != 0 ;

	m_cpu->s[ sX ] <<= 1 ;
	if ( c )
		m_cpu->s[ sX ] |= 1 ;
	
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movb 0x11(%rax), %cl
movzwl 0x10(%rdi), %edx
movb (%rax,%rdx), %sil
shrb $0x7, %sil
movb %sil, 0x11(%rax)
shlb (%rax,%rdx)
cmpb $0x1, %cl
jne 0x40aa0b
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
orb $0x1, (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SLX_SX::Execute()
void SLX_SX::Execute()
{
	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x80 ) != 0 ;

	m_cpu->s[ sX ] <<= 1 ;
	if ( m_cpu->s[ sX ] & 0x02 )
		m_cpu->s[ sX ] |= 1 ;
	
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
shrb $0x7, %dl
movb %dl, 0x11(%rax)
shlb (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
testb $0x2, %dl
je 0x40aa8a
orb $0x1, %dl
movb %dl, (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SR0_SX::Execute()
void SR0_SX::Execute()
{
	m_cpu->flags.carry = m_cpu->s[ sX ] & 0x01 ;
	m_cpu->s[ sX ] >>= 1 ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
andb $0x1, %dl
movb %dl, 0x11(%rax)
shrb (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SRA_SX::Execute()
void SRA_SX::Execute()
{
	bool c = m_cpu->flags.carry ;
	m_cpu->flags.carry = m_cpu->s[ sX ] & 0x01 ;
	m_cpu->s[ sX ] >>= 1 ;
	if ( c )
		m_cpu->s[ sX ] |= 0x80 ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movb 0x11(%rax), %cl
movzwl 0x10(%rdi), %edx
movb (%rax,%rdx), %sil
andb $0x1, %sil
movb %sil, 0x11(%rax)
shrb (%rax,%rdx)
cmpb $0x1, %cl
jne 0x40abe5
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
orb $-0x80, (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SRX_SX::Execute()
void SRX_SX::Execute()
{
	m_cpu->flags.carry = m_cpu->s[ sX ] & 0x01 ;
	m_cpu->s[ sX ] >>= 1 ;
	if ( m_cpu->s[ sX ] & 0x40  )
		m_cpu->s[ sX ] |= 0x80 ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
andb $0x1, %dl
movb %dl, 0x11(%rax)
shrb (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
testb $0x40, %dl
je 0x40ac64
orb $-0x80, %dl
movb %dl, (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SUB_SX_KK::Execute()
void SUB_SX_KK::Execute()
{
	int val ;
	
	val = m_cpu->s[ sX ] ;
	val -= kk ;

	m_cpu->flags.carry = val < 0 ;
	m_cpu->flags.zero = val == 0 ;
	
	m_cpu->s[ sX ] -= kk ;

	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movzbl (%rax,%rcx), %edx
movzwl 0x18(%rdi), %esi
cmpl %esi, %edx
setb 0x11(%rax)
sete 0x10(%rax)
subb %sil, (%rax,%rcx)
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SUB_SX_SY::Execute()
void SUB_SX_SY::Execute()
{
	int val ;
	
	val = m_cpu->s[ sX ] ;
	val -= m_cpu->s[ sY ] ;

	m_cpu->flags.carry = val < 0 ;
	m_cpu->flags.zero = val == 0 ;
	
	m_cpu->s[ sX ] -= m_cpu->s[ sY ] ;

	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
movzwl 0x12(%rdi), %esi
cmpb (%rax,%rsi), %dl
setb 0x11(%rax)
sete 0x10(%rax)
movb (%rax,%rsi), %dl
subb %dl, (%rax,%rcx)
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SUBCY_SX_KK::Execute()
void SUBCY_SX_KK::Execute()
{
	int val ;
	bool c = m_cpu->flags.carry ;	
	val = m_cpu->s[ sX ] ;
	val -= kk ;
	if ( c )
		val -= 1 ;

	m_cpu->flags.carry = val < 0 ;
	m_cpu->flags.zero = val == 0 ;
	m_cpu->s[ sX ] -= kk ;
	if ( c )
		c -= 1 ;

	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzbl 0x11(%rax), %ecx
movzwl 0x10(%rdi), %edx
movzbl (%rax,%rdx), %esi
movzwl 0x18(%rdi), %r8d
addl %r8d, %ecx
cmpl %esi, %ecx
seta 0x11(%rax)
sete 0x10(%rax)
subb %r8b, (%rax,%rdx)
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: SUBCY_SX_SY::Execute()
void SUBCY_SX_SY::Execute()
{
	int val ;
	bool c = m_cpu->flags.carry ;	
	val = m_cpu->s[ sX ] ;
	val -= m_cpu->s[ sY ] ;
	if ( c )
		val -= 1 ;

	m_cpu->flags.carry = val < 0 ;
	m_cpu->flags.zero = val == 0 ;
	m_cpu->s[ sX ] -= kk ;
	if ( c )
		c -= 1 ;

	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzbl 0x11(%rax), %ecx
movzwl 0x10(%rdi), %edx
movzbl (%rax,%rdx), %esi
movzwl 0x12(%rdi), %r8d
movzbl (%rax,%r8), %r8d
addl %ecx, %r8d
cmpl %esi, %r8d
seta 0x11(%rax)
sete 0x10(%rax)
movb 0x18(%rdi), %cl
subb %cl, (%rax,%rdx)
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: TEST_SX_KK::Execute()
void TEST_SX_KK::Execute()
{
	uint8_t and_test = ( m_cpu->s[ sX ] & kk ) ;
	m_cpu->flags.zero = and_test == 0 ;

	int i ;

	uint8_t xor_test = 0, b ;

	for ( i = 0 ; i < 8 ; i++ ) {
		b = ( and_test & ( 1 << i ) ) != 0 ; 
		xor_test = b ^ xor_test ;	
	}

	m_cpu->flags.carry = xor_test != 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movzbl (%rax,%rcx), %edx
movzbl 0x18(%rdi), %ecx
andl %edx, %ecx
sete 0x10(%rax)
xorl %edx, %edx
xorl %r8d, %r8d
movl %r8d, %esi
btl %edx, %ecx
setb %dil
movl %edi, %r8d
xorb %sil, %r8b
incl %edx
cmpl $0x8, %edx
jne 0x40b029
pushq %rbp
movq %rsp, %rbp
cmpb %sil, %dil
setne 0x11(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: TEST_SX_SY::Execute()
void TEST_SX_SY::Execute()
{
	uint8_t and_test = ( m_cpu->s[ sX ] & m_cpu->s[ sY ] ) ;
	m_cpu->flags.zero = and_test == 0 ;

	int i ;

	uint8_t xor_test = 0, b ;

	for ( i = 0 ; i < 8 ; i++ ) {
		b = ( and_test & ( 1 << i ) ) != 0 ; 
		xor_test = b ^ xor_test ;	
	}

	m_cpu->flags.carry = xor_test != 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movzbl (%rax,%rcx), %edx
movzwl 0x12(%rdi), %ecx
movzbl (%rax,%rcx), %ecx
andl %edx, %ecx
sete 0x10(%rax)
xorl %edx, %edx
xorl %r8d, %r8d
movl %r8d, %esi
btl %edx, %ecx
setb %dil
movl %edi, %r8d
xorb %sil, %r8b
incl %edx
cmpl $0x8, %edx
jne 0x40b0cd
pushq %rbp
movq %rsp, %rbp
cmpb %sil, %dil
setne 0x11(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: XOR_SX_KK::Execute()
void XOR_SX_KK::Execute()
{
	m_cpu->s[ sX ] ^= kk ;
	
	m_cpu->flags.carry = false ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x18(%rdi), %al
movq 0x8(%rdi), %rcx
movzwl 0x10(%rdi), %edx
xorb %al, (%rcx,%rdx)
movq 0x8(%rdi), %rax
movb $0x0, 0x11(%rax)
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: XOR_SX_SY::Execute()
void XOR_SX_SY::Execute()
{
	m_cpu->s[ sX ] ^= m_cpu->s[ sY ] ;
	
	m_cpu->flags.carry = false ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x12(%rdi), %ecx
movb (%rax,%rcx), %cl
movzwl 0x10(%rdi), %edx
xorb %cl, (%rax,%rdx)
movq 0x8(%rdi), %rax
movb $0x0, 0x11(%rax)
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RESET_EVENT::Execute()
void RESET_EVENT::Execute() 
{
	m_cpu->pc->Set( 0 ) ;
	m_cpu->flags.interrupt_enable = false ;
	m_cpu->flags.zero = false ;
	m_cpu->flags.carry = false ;
	m_cpu->stack->Reset() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
callq 0x40b706
movq 0x8(%rbx), %rax
movb $0x0, 0x12(%rax)
movw $0x0, 0x10(%rax)
movq 0x28(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b87e
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: INTERRUPT_EVENT::Execute()
void INTERRUPT_EVENT::Execute()
{
	if ( m_cpu->flags.interrupt_enable ) {
		m_cpu->flags.interrupt_enable = false ;
		m_cpu->stack->Push( m_cpu->pc->Get() ) ;
		m_cpu->flags.preserved_carry = m_cpu->flags.carry ;
		m_cpu->flags.preserved_zero = m_cpu->flags.zero ;
		m_cpu->pc->Set( 0x3FF ) ;	
	}
}

// Assembly:
movq 0x8(%rdi), %rax
cmpb $0x1, 0x12(%rax)
jne 0x40b308
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x12(%rax)
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b716
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b760
movq 0x8(%rbx), %rax
movzwl 0x10(%rax), %ecx
movw %cx, 0x13(%rax)
movq 0x18(%rax), %rdi
movl $0x3ff, %esi            # imm = 0x3FF
popq %rbx
popq %r14
popq %rbp
jmp 0x40b706
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CStack::Push(unsigned short)
void CStack::Push( uint16_t data )
{	
	data &= 0x3FF ;
	if ( ptr == STACK_DEPTH - 1 )
	  cout << ">>>>Stack overflow!<<<<" << endl ;
		
	stack[ ptr ] = data ;
	ptr = ( ptr + 1 ) % STACK_DEPTH ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x1e, 0x3e(%rdi)
jne 0x40b7b8
movq $0x5f4580, %r15         # imm = 0x5F4580
leaq 0x176628(%rip), %rsi    # 0x581dac
movl $0x17, %edx
movq %r15, %rdi
callq 0x4761b0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %r15, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
andl $0x3ff, %r14d           # imm = 0x3FF
movzbl 0x3e(%rbx), %eax
movw %r14w, (%rbx,%rax,2)
movl %eax, %ecx
incl %ecx
imull $0x843, %ecx, %ecx      # imm = 0x843
shrl $0x10, %ecx
movl %ecx, %edx
shll $0x5, %edx
subl %edx, %ecx
addl %ecx, %eax
incl %eax
movb %al, 0x3e(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CStack::Pop()
uint16_t CStack::Pop()
{
	if ( ptr == 0 )
	  cout << ">>>>Stack underflow!<<<<" << endl ;
		
	ptr = ( ptr - 1 ) % STACK_DEPTH ;
	return stack[ ptr ] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x3e(%rdi)
jne 0x40b840
movq $0x5f4580, %r14         # imm = 0x5F4580
leaq 0x1765b8(%rip), %rsi    # 0x581dc4
movl $0x18, %edx
movq %r14, %rdi
callq 0x4761b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %r14, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
movzbl 0x3e(%rbx), %eax
movl %eax, %ecx
decl %ecx
movslq %ecx, %rcx
imulq $-0x7bdef7bd, %rcx, %rcx # imm = 0x84210843
shrq $0x20, %rcx
addl %eax, %ecx
decl %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x4, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x5, %edx
subl %edx, %ecx
addl %ecx, %eax
decl %eax
movb %al, 0x3e(%rbx)
movzbl %al, %eax
movzwl (%rbx,%rax,2), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CPort::PortIn()
uint8_t CPort::PortIn()
{
	// find appropiate port 
	list<CIOPort*>::iterator i ;
	
	for ( i = portList.begin() ; i != portList.end() ; i++ ) 
		if ( (*i)->getID() == portid && (*i)->isReadable() )
			return (*i)->In() ;
	
	
	// Nothing found return zero
	return 0 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8(%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0x40b979
movzwl (%rdi), %edx
movq 0x10(%rcx), %rdi
movzbl 0x8(%rdi), %esi
cmpw %si, %dx
jne 0x40b971
testb $0x1, 0xc(%rdi)
jne 0x40b97d
movq (%rcx), %rcx
cmpq %rax, %rcx
jne 0x40b95e
xorl %eax, %eax
popq %rbp
retq
movq (%rdi), %rax
popq %rbp
jmpq *0x8(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CPort::PortOut(unsigned char)
void CPort::PortOut( uint8_t data )
{
	// find appropiate port 
	list<CIOPort*>::iterator i ;
	
	for ( i = portList.begin() ; i != portList.end() ; i++ ) 
		if ( (*i)->getID() == portid && (*i)->isWriteable() )
			(*i)->Out( data ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r15, %r12
je 0x40b9c8
movq %rdi, %rbx
movzbl %sil, %r14d
movq 0x10(%r12), %rdi
movzbl 0x8(%rdi), %eax
cmpw %ax, (%rbx)
jne 0x40b9bf
testb $0x2, 0xc(%rdi)
je 0x40b9bf
movq (%rdi), %rax
movl %r14d, %esi
callq *(%rax)
movq (%r12), %r12
cmpq %r15, %r12
jne 0x40b9a3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CCode::ClearCode()
void CCode::ClearCode() {	
	int i ;
	for ( i = 0 ; i < MAX_ADDRESS ; i++ )
		if ( CodeMap[ i ] != NULL ) {
			delete CodeMap[ i ] ;
			CodeMap[ i ] = NULL ;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x40ba48
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rbx,%r14,8)
incq %r14
cmpq $0x400, %r14            # imm = 0x400
jne 0x40ba2f
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CCode::setInstruction(unsigned short, unsigned int, unsigned int)
bool CCode::setInstruction( uint16_t address, uint32_t code, unsigned int sourceLine )
{
	CInstruction *instr = Disassemble( code ) ;
	if ( instr == NULL ) {
	  cout << ">>>>Unknown code at address " << address << "<<<<" << endl ;
		return FALSE ;
	}
	
	if ( address >= MAX_ADDRESS ) {
	  cout << ">>>>Invalid address" << address << "<<<<" << endl ;
		delete instr ;
		return FALSE ;
	}
	
	
	if ( CodeMap[ address ] != NULL ) {
	  cout << ">>>>Code is placed at same address (" << address << ")<<<<" << endl ;
		delete instr ;
		return FALSE ;
	}
	
	instr->setSourceLine( sourceLine ) ;
	CodeMap[ address ] = instr ;
	
	return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %esi, %r13d
movq %rdi, %r12
movl %edx, %esi
callq 0x40ba5a
movl %r13d, %r14d
testq %rax, %rax
je 0x40c534
movq %rax, %rbx
movzwl %r13w, %eax
cmpl $0x400, %eax            # imm = 0x400
jb 0x40c59a
movq $0x5f4580, %r15         # imm = 0x5F4580
leaq 0x175901(%rip), %rsi    # 0x581e09
movl $0x13, %edx
movq %r15, %rdi
callq 0x4761b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x476ab0
movq %rax, %r14
leaq 0x1758ae(%rip), %rsi    # 0x581dd8
movl $0x4, %edx
jmp 0x40c5d7
movq $0x5f4580, %rbx         # imm = 0x5F4580
leaq 0x1758aa(%rip), %rsi    # 0x581dec
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x4761b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x476ab0
movq %rax, %rbx
leaq 0x175874(%rip), %rsi    # 0x581dd8
movl $0x4, %edx
movq %rax, %rdi
callq 0x4761b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
jmp 0x40c60f
cmpq $0x0, 0x8(%r12,%r14,8)
je 0x40c620
movq $0x5f4580, %r15         # imm = 0x5F4580
leaq 0x17586d(%rip), %rsi    # 0x581e1d
movl $0x24, %edx
movq %r15, %rdi
callq 0x4761b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x476ab0
movq %rax, %r14
leaq 0x175870(%rip), %rsi    # 0x581e42
movl $0x5, %edx
movq %rax, %rdi
callq 0x4761b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %r14, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, 0x20(%rbx)
movq %rbx, 0x8(%r12,%r14,8)
movb $0x1, %al
jmp 0x40c611
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CCode::Print()
void CCode::Print()
{
	int i ;
	
	cout << "----listing----" << endl ;
	for ( i = 0 ; i < MAX_ADDRESS ;  i++ ) {
		if ( CodeMap[ i ] != NULL ) {
			cout << i << "  : " ;
			CodeMap[ i ]->Print() ;
			cout << endl ;
		}
	}
	cout << "----end listing----" << endl ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq $0x5f4580, %rbx         # imm = 0x5F4580
leaq 0x1757e4(%rip), %rsi    # 0x581e48
movl $0xf, %edx
movq %rbx, %rdi
callq 0x4761b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
xorl %r15d, %r15d
leaq 0x1757b6(%rip), %r12    # 0x581e58
cmpq $0x0, 0x8(%r14,%r15,8)
je 0x40c6f7
movq %rbx, %rdi
movl %r15d, %esi
callq 0x476a80
movl $0x4, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4761b0
movq 0x8(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
incq %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0x40c6a2
leaq 0x175753(%rip), %rsi    # 0x581e5d
movl $0x13, %edx
movq %rbx, %rdi
callq 0x4761b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x475280
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CPicoBlaze::CPicoBlaze()
CPicoBlaze::CPicoBlaze()
{
	flags.zero = false ;
	flags.carry = false ;
	flags.interrupt_enable = false ;

	scratch = new CScratchPad ;
	pc = new CProgramCounter ;
	stack = new CStack ;
	port = new CPort ;
	code = new CCode( this ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movw %r14w, 0x10(%rdi)
movb $0x0, 0x12(%rdi)
movl $0x40, %edi
callq 0x40df60
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq %rax, 0x20(%rbx)
movl $0x2, %edi
callq 0x40df60
movw %r14w, (%rax)
movq %rax, 0x18(%rbx)
movl $0x40, %edi
callq 0x40df60
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x2f(%rax)
movq %rax, 0x28(%rbx)
movl $0x20, %edi
callq 0x40df60
leaq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq %rax, 0x30(%rbx)
movl $0x2008, %edi           # imm = 0x2008
callq 0x40df60
movq %rax, %r14
movq %rbx, (%rax)
leaq 0x8(%rax), %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x401090
movq %r14, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CPicoBlaze::~CPicoBlaze()
CPicoBlaze::~CPicoBlaze()
{
	delete scratch ;
	delete pc ;
	delete stack ;
	delete port ;
	delete code ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x40c81b
movl $0x40, %esi
callq 0x40d0c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40c82e
movl $0x2, %esi
callq 0x40d0c0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x40c841
movl $0x40, %esi
callq 0x40d0c0
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x40c879
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
cmpq %r15, %rdi
je 0x40c86c
movq (%rdi), %r12
movl $0x18, %esi
callq 0x40d0c0
movq %r12, %rdi
cmpq %r15, %r12
jne 0x40c857
movl $0x20, %esi
movq %r14, %rdi
callq 0x40d0c0
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
je 0x40c8c0
movl $0x1, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x40c89f
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx,%r14,8)
incq %r14
cmpq $0x401, %r14            # imm = 0x401
jne 0x40c888
movl $0x2008, %esi           # imm = 0x2008
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x40d0c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CPicoBlaze::Print()
void CPicoBlaze::Print()
{
	int i ;
	
	cout << "----CPU----" << endl ;
	cout << "regs|" ;
	for ( i = 0 ; i < 15 ; i++ ) 
		cout << "s" << i << "=" << (int) s[ i ]  << "|" ;
	cout << endl ;
	
	cout << "flags|";
	cout << "c=" << flags.carry ;
	cout << "|z=" << flags.zero ;
	cout << "|ie=" << flags.interrupt_enable << "|" << endl ;
	cout << "----end CPU----" << endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq $0x5f4580, %rbx         # imm = 0x5F4580
leaq 0x17546f(%rip), %rsi    # 0x581e71
movl $0xb, %edx
movq %rbx, %rdi
callq 0x4761b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
leaq 0x175440(%rip), %rsi    # 0x581e7d
movl $0x5, %edx
movq %rbx, %rdi
callq 0x4761b0
xorl %r15d, %r15d
leaq 0x174e22(%rip), %r12    # 0x581876
leaq 0x179178(%rip), %r13    # 0x585bd3
leaq 0x175426(%rip), %rbx    # 0x581e88
movl $0x1, %edx
movq $0x5f4580, %r14         # imm = 0x5F4580
movq %r14, %rdi
movq %r12, %rsi
callq 0x4761b0
movq %r14, %rdi
movl %r15d, %esi
callq 0x476a80
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x4761b0
movq -0x30(%rbp), %rax
movzbl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x476a80
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4761b0
incq %r15
cmpq $0xf, %r15
jne 0x40ca62
movq $0x5f4580, %r14         # imm = 0x5F4580
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %r14, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
leaq 0x17538d(%rip), %rsi    # 0x581e83
movl $0x6, %edx
movq %r14, %rdi
callq 0x4761b0
leaq 0x175380(%rip), %rsi    # 0x581e8a
movl $0x2, %edx
movq %r14, %rdi
callq 0x4761b0
movq -0x30(%rbp), %rbx
movzbl 0x11(%rbx), %esi
movq %r14, %rdi
callq 0x476d20
leaq 0x17535f(%rip), %rsi    # 0x581e8d
movl $0x3, %edx
movq %r14, %rdi
callq 0x4761b0
movzbl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x476d20
leaq 0x175343(%rip), %rsi    # 0x581e91
movl $0x4, %edx
movq %r14, %rdi
callq 0x4761b0
movzbl 0x12(%rbx), %esi
movq %r14, %rdi
callq 0x476d20
movq %rax, %rbx
leaq 0x175317(%rip), %rsi    # 0x581e88
movl $0x1, %edx
movq %rax, %rdi
callq 0x4761b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
leaq 0x1752ea(%rip), %rsi    # 0x581e96
movl $0xf, %edx
movq %r14, %rdi
callq 0x4761b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %r14, %rdi
callq 0x475cb0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x475280
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CPicoBlaze::GetNextSourceLine()
unsigned int CPicoBlaze::GetNextSourceLine()
{
	CInstruction *instr = code->getInstruction( pc->Get() ) ;
	if ( instr == NULL ) {
	  cout << ">>>>Error in simulation (No code found at " << pc->Get() << ")<<<<" << endl ;
		return FALSE ;
	}

	return instr->getSourceLine() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movzwl (%rax), %eax
cmpq $0x3ff, %rax            # imm = 0x3FF
jbe 0x40cc0b
xorl %eax, %eax
jmp 0x40cc14
movq 0x38(%rbx), %rcx
movq 0x8(%rcx,%rax,8), %rax
testq %rax, %rax
je 0x40cc1e
movl 0x20(%rax), %eax
jmp 0x40cc88
movq $0x5f4580, %r14         # imm = 0x5F4580
leaq 0x17527a(%rip), %rsi    # 0x581ea6
movl $0x2a, %edx
movq %r14, %rdi
callq 0x4761b0
movq 0x18(%rbx), %rax
movzwl (%rax), %esi
movq %r14, %rdi
callq 0x476ab0
movq %rax, %rbx
leaq 0x1751f0(%rip), %rsi    # 0x581e42
movl $0x5, %edx
movq %rax, %rdi
callq 0x4761b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cpicoblaze.cpp
// Function: CPicoBlaze::Next()
bool CPicoBlaze::Next()
{
	CInstruction *instr = code->getInstruction( pc->Get() ) ;
	if ( instr == NULL ) {
	  cout << ">>>>Error in simulation (No code found at " << pc->Get() << ")<<<<" << endl ;
		return FALSE ;
	}

	instr->Execute() ;
		
	return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rax
movzwl (%rax), %eax
cmpq $0x3ff, %rax            # imm = 0x3FF
jbe 0x40ccae
xorl %ebx, %ebx
jmp 0x40ccb7
movq 0x38(%r14), %rcx
movq 0x8(%rcx,%rax,8), %rbx
testq %rbx, %rbx
je 0x40ccc7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x40cd2f
movq $0x5f4580, %r15         # imm = 0x5F4580
leaq 0x1751d1(%rip), %rsi    # 0x581ea6
movl $0x2a, %edx
movq %r15, %rdi
callq 0x4761b0
movq 0x18(%r14), %rax
movzwl (%rax), %esi
movq %r15, %rdi
callq 0x476ab0
movq %rax, %r14
leaq 0x175147(%rip), %rsi    # 0x581e42
movl $0x5, %edx
movq %rax, %rdi
callq 0x4761b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %r14, %rdi
callq 0x475cb0
movq %rax, %rdi
callq 0x475280
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./cpuuse.h
// Function: cal_cpuoccupy(CPU_OCCUPY*, CPU_OCCUPY*)
double cal_cpuoccupy(CPU_OCCUPY *o, CPU_OCCUPY *n)
{
	unsigned int od, nd;
	unsigned int id, sd;
	double cpu_use = 0;
	double st,tol;

	od = (unsigned int)(o->user + o->nice + o->system + o->idle);//��һ��(�û�+���ȼ�+ϵͳ+����)��ʱ���ٸ���od
	nd = (unsigned int)(n->user + n->nice + n->system + n->idle);//�ڶ���(�û�+���ȼ�+ϵͳ+����)��ʱ���ٸ���od

	id = (unsigned int)(n->user - o->user);    //�û���һ�κ͵ڶ��ε�ʱ��֮���ٸ���id
	sd = (unsigned int)(n->system - o->system);//ϵͳ��һ�κ͵ڶ��ε�ʱ��֮���ٸ���sd
	st=sd+id;
	tol=nd-od;
    printf("%.2f,%.2f\n",st,tol);
	if (tol != 0)
		cpu_use = (st * 100) / tol; //((�û�+ϵͳ)��100)��(��һ�κ͵ڶ��ε�ʱ����)�ٸ���g_cpu_used
	else 
		cpu_use = 0;
	//printf("cpu: %.2f\%\n", cpu_use);
	return cpu_use;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x14(%rdi), %ecx
movl 0x1c(%rdi), %edx
movl 0x18(%rdi), %eax
addl %ecx, %eax
addl %edx, %eax
addl 0x20(%rdi), %eax
movl 0x14(%rsi), %edi
movl 0x1c(%rsi), %r8d
movl 0x18(%rsi), %r9d
addl %edi, %r9d
addl %r8d, %r9d
addl 0x20(%rsi), %r9d
addl %ecx, %edx
subl %edx, %edi
addl %r8d, %edi
cvtsi2sd %rdi, %xmm0
leaq 0x46cb(%rip), %rdi      # 0x8057
xorpd %xmm2, %xmm2
subl %eax, %r9d
cvtsi2sd %r9, %xmm1
je 0x39aa
movsd 0x4666(%rip), %xmm2     # 0x8008
mulsd %xmm0, %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, -0x8(%rbp)
movb $0x2, %al
callq 0x3050
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./cpuuse.h
// Function: get_cpuoccupy(CPU_OCCUPY*)
void get_cpuoccupy(CPU_OCCUPY *cpust) //��������get��������һ���βνṹ����Ū��ָ��O
{
	FILE *fd;
	int n;
	char buff[256];
	CPU_OCCUPY *cpu_occupy;
	cpu_occupy = cpust;

	fd = fopen("/proc/stat", "r");
	fgets(buff, sizeof(buff), fd);

	sscanf(buff, "%s %u %u %u %u", cpu_occupy->name, &cpu_occupy->user, &cpu_occupy->nice, &cpu_occupy->system, &cpu_occupy->idle);
	//printf("name = %s, user = %u, nice = %u, system = %u , idle = %u \n", cpu_occupy->name, cpu_occupy->user, cpu_occupy->nice, cpu_occupy->system, cpu_occupy->idle);

	fclose(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0x4687(%rip), %rdi      # 0x8062
leaq 0x47e5(%rip), %rsi      # 0x81c7
callq 0x3440
movq %rax, %r14
leaq -0x120(%rbp), %r15
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rax, %rdx
callq 0x35b0
leaq 0x14(%rbx), %rcx
leaq 0x18(%rbx), %r8
leaq 0x1c(%rbx), %r9
leaq 0x20(%rbx), %rax
movq %rax, (%rsp)
leaq 0x4651(%rip), %rsi      # 0x806d
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3390
movq %r14, %rdi
callq 0x33a0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./cpuuse.h
// Function: cpuuse()
int cpuuse()
{
	CPU_OCCUPY cpu_stat1;
	CPU_OCCUPY cpu_stat2;
	double cpu;
	//��һ�λ�ȡcpuʹ������
	//printf("===============================cpu use================================\n");
	get_cpuoccupy((CPU_OCCUPY *)&cpu_stat1);
	sleep(5);

	//�ڶ��λ�ȡcpuʹ������
	get_cpuoccupy((CPU_OCCUPY *)&cpu_stat2);

	//����cpuʹ����
	cpu = cal_cpuoccupy((CPU_OCCUPY *)&cpu_stat1, (CPU_OCCUPY *)&cpu_stat2);
	printf("cpu use = %.2f\%\n", cpu);
	//printf("======================================================================\n");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x39c1
movl $0x5, %edi
callq 0x3260
leaq -0x34(%rbp), %r14
movq %r14, %rdi
callq 0x39c1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x394c
leaq 0x45fe(%rip), %rdi      # 0x807c
movb $0x1, %al
callq 0x3050
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./maile.h
// Function: CAutoMail::init_socket()
bool CAutoMail::init_socket()
{
	char _buf_svr[BUF_LEN] = {0};
	wcstombs(_buf_svr, m_str_email_server.data(), m_str_email_server.length()+1);
	hostent *host_server = gethostbyname(_buf_svr);

	if (host_server == NULL)
	{
		ERROR_NUMBER = CHANGE_URL_TO_IP_FAILED;
		return false;
	}

	m_socket_server = socket(AF_INET,SOCK_STREAM,0);
	if (m_socket_server < 0)
	{
		ERROR_NUMBER = CREATE_SOCKET_FAILED;
		return false;
	}

	m_sockaddr_server.sin_family = AF_INET;
 	m_sockaddr_server.sin_port = htons(m_ns_server_port);
	m_sockaddr_server.sin_addr = *((struct in_addr *)host_server->h_addr);
	memset(&(m_sockaddr_server.sin_zero), 0, 8) ;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
leaq -0x110(%rbp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x31d0
movq 0x308(%rbx), %rsi
movq 0x310(%rbx), %rdx
incq %rdx
movq %r14, %rdi
callq 0x3330
movq %r14, %rdi
callq 0x3410
testq %rax, %rax
je 0x43c4
movq %rax, %r14
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3080
movl %eax, 0x32c(%rbx)
testl %eax, %eax
js 0x43d0
movw $0x2, 0x330(%rbx)
movzwl 0x328(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x332(%rbx)
movq 0x18(%r14), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x334(%rbx)
movq $0x0, 0x338(%rbx)
movb $0x1, %al
jmp 0x43dc
movl $0x14, 0x6fe2(%rip)     # 0xb3b0
jmp 0x43da
movl $0x12, 0x6fd6(%rip)     # 0xb3b0
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./maile.h
// Function: CAutoMail::uninit()
void CAutoMail::uninit()
{
	shutdown(m_socket_server, SHUT_RDWR);
	close(m_socket_server);
	char _buf[BUF_LEN] = {0};
	
	memset(_buf, 0, sizeof(_buf));
	sprintf(_buf, "rm -f %s", STR_BASE_FILE);
	system(_buf);
	
	memset(_buf, 0, sizeof(_buf));
	sprintf(_buf, "rm -f %s", STR_TMP_FILE);
	system(_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movl 0x32c(%rdi), %edi
movl $0x2, %esi
callq 0x34b0
movl 0x32c(%rbx), %edi
callq 0x36f0
leaq -0x110(%rbp), %rbx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31d0
movq 0x6f67(%rip), %rdx      # 0xb398
leaq 0x3c88(%rip), %r14      # 0x80c0
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3070
movq %rbx, %rdi
callq 0x3320
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31d0
movq 0x6f2d(%rip), %rdx      # 0xb390
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3070
movq %rbx, %rdi
callq 0x3320
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./maile.h
// Function: CAutoMail::base64(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, char const*)
bool CAutoMail::base64(wstring data, const char *dst_file)
{
	if (dst_file == NULL)
	{
		ERROR_NUMBER = PARAM_INCORRECT;
		return false;
	}

	wofstream _ofs(STR_TMP_FILE); // create temp file to store data
	_ofs << data.data();
	_ofs.close();
	
	char buf[BUF_LEN] = {0}; // to encode data with base64 by shell
	sprintf(buf,"base64 %s >> %s", STR_TMP_FILE, dst_file);
	system(buf);

	memset(buf, 0, sizeof(buf));
	sprintf(buf, "rm -f %s", STR_TMP_FILE);
	system(buf);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rdx, %rbx
testq %rdx, %rdx
je 0x44d9
movq %rsi, %r14
movq 0x6eec(%rip), %rsi      # 0xb390
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x34a0
movq (%r14), %r14
testq %r14, %r14
je 0x44e8
movq %r14, %rdi
callq 0x3310
leaq -0x210(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3110
jmp 0x4509
movl $0x10, 0x6ecd(%rip)     # 0xb3b0
jmp 0x45b3
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %rdi
addq $-0x210, %rdi           # imm = 0xFDF0
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x3510
leaq -0x210(%rbp), %rdi
callq 0x3490
leaq -0x310(%rbp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x31d0
movq 0x6e5e(%rip), %rdx      # 0xb390
leaq 0x3b90(%rip), %rsi      # 0x80c9
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
callq 0x3320
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x31d0
movq 0x6e2c(%rip), %rdx      # 0xb390
leaq 0x3b55(%rip), %rsi      # 0x80c0
movq %r14, %rdi
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
callq 0x3320
movq 0x6a5c(%rip), %rax      # 0xafe0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x33e0
leaq -0x118(%rbp), %rdi
callq 0x30d0
testq %rbx, %rbx
setne %al
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x45c7
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x3590
movq %rbx, %rdi
callq 0x3630
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./maile.h
// Function: CAutoMail::get_time(char*)
void CAutoMail::get_time(char *time_buf)
{
	if (time_buf == NULL)
		return;
	time_t tt = time(NULL);
	struct tm *time_now = localtime(&tt);
	sprintf(time_buf, "%d-%d-%d-%d:%d:%d", time_now->tm_year+1900, time_now->tm_mon+1, time_now->tm_mday, time_now->tm_hour, 
	        time_now->tm_min, time_now->tm_sec);
}

// Assembly:
testq %rsi, %rsi
je 0x4636
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %edi, %edi
callq 0x3350
leaq -0x10(%rbp), %rdi
movq %rax, (%rdi)
callq 0x3250
movl $0x76c, %edx            # imm = 0x76C
addl 0x14(%rax), %edx
movl 0x10(%rax), %ecx
incl %ecx
movl 0xc(%rax), %r8d
movl 0x8(%rax), %r9d
movl (%rax), %r10d
movl 0x4(%rax), %r11d
leaq 0x3ab7(%rip), %rsi      # 0x80d9
movq %rbx, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x3070
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/./maile.h
// Function: run_mail()
int run_mail()
{
	CAutoMail automail;
	automail.init();
	if(!automail.send_mail())
		cout<<automail.get_error_no()<<endl;
	automail.uninit();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
leaq -0x348(%rbp), %rbx
movq %rbx, %rdi
callq 0x3a90
movq %rbx, %rdi
callq 0x3dd0
leaq -0x348(%rbp), %rdi
callq 0x4320
leaq -0x348(%rbp), %rdi
callq 0x4eac
testb %al, %al
jne 0x5328
movl 0x60be(%rip), %esi      # 0xb3b0
movq 0x5cbf(%rip), %rdi      # 0xafb8
callq 0x3210
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3220
leaq -0x348(%rbp), %rdi
callq 0x43e8
leaq -0x348(%rbp), %rdi
callq 0x3c9e
xorl %eax, %eax
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x348(%rbp), %rdi
callq 0x3c9e
movq %rbx, %rdi
callq 0x3630
nop
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/watchdog.cpp
// Function: PidTracker::PidTracker()
PidTracker::PidTracker() 
{
	  char path[80];
	  snprintf(path, sizeof(path), "/sys/fs/cgroup/cpu/%d.supervisor", getpid());
	  int rv = mkdir(path, 0777);

	  if (rv < 0) 
	  {
		perror("PidTracker: mkdir");
	  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x3550
leaq 0x2e0a(%rip), %rdx      # 0x8196
leaq -0x60(%rbp), %rbx
movl $0x50, %esi
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x35c0
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3160
testl %eax, %eax
js 0x53b9
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2df7(%rip), %rdi      # 0x81b7
addq $0x58, %rsp
popq %rbx
popq %rbp
jmp 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/watchdog.cpp
// Function: PidTracker::add(int)
void PidTracker::add(int pid) 
{
	  char path[80];
	  snprintf(path, sizeof(path), "/sys/fs/cgroup/cpu/%d.supervisor/tasks",
			   getpid());

	  char buf[64];
	  ssize_t n = snprintf(buf, sizeof(buf), "%d", pid);

	  int fd = open(path, O_WRONLY);
	  write(fd, buf, n);
	  close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebx
callq 0x3550
leaq 0x2d89(%rip), %rdx      # 0x81c9
leaq -0xb0(%rbp), %r14
movl $0x50, %esi
movq %r14, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x35c0
leaq 0x2dbe(%rip), %rdx      # 0x821d
leaq -0x60(%rbp), %r15
movl $0x40, %esi
movq %r15, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x35c0
movslq %eax, %rbx
movq %r14, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x3240
movl %eax, %r14d
movl %eax, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x30f0
movl %r14d, %edi
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/watchdog.cpp
// Function: PidTracker::collectAll()
std::vector<int> PidTracker::collectAll() 
{
	  std::vector<int> result;

	  char path[80];
	  snprintf(path, sizeof(path), "/sys/fs/cgroup/cpu/%d.supervisor/tasks",
			   getpid());

	  std::ifstream tasksFile(path);
	  std::string line;

	  while (std::getline(tasksFile, line)) 
	  {
		result.push_back(stoi(line));
	  }

	  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x3550
leaq 0x2cec(%rip), %rdx      # 0x81c9
leaq -0xb0(%rbp), %r15
movl $0x50, %esi
movq %r15, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x35c0
leaq -0x2b8(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x3670
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq -0x2b8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3380
movsbl %al, %edx
movq %r14, %rdi
leaq -0x58(%rbp), %rsi
callq 0x36a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x55c6
movq -0x58(%rbp), %r12
callq 0x3040
movq %rax, %r13
movl (%rax), %r15d
movl $0x0, (%rax)
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
movl $0xa, %edx
callq 0x34d0
cmpq %r12, -0x38(%rbp)
je 0x55f9
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x5605
movl (%r13), %ecx
cmpl $0x22, %ecx
je 0x5605
testl %ecx, %ecx
jne 0x5599
movl %r15d, (%r13)
movl %eax, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x55b5
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x551f
movq %rbx, %rdi
leaq -0x2c(%rbp), %rdx
callq 0x703a
jmp 0x551f
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x55d8
callq 0x3370
leaq -0x2b8(%rbp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ed5(%rip), %rdi      # 0x84d5
callq 0x31f0
leaq 0x2ec9(%rip), %rdi      # 0x84d5
callq 0x3530
movq %rax, %r14
jmp 0x5649
jmp 0x5628
movq %rax, %r14
cmpl $0x0, (%r13)
jne 0x562b
movl %r15d, (%r13)
jmp 0x562b
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x563d
callq 0x3370
leaq -0x2b8(%rbp), %rdi
callq 0x3090
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5656
callq 0x3370
movq %r14, %rdi
callq 0x3630
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/watchdog.cpp
// Function: Program::spawn()
bool Program::spawn() 
	{
	  logger_->info("starting program (%s)...", exe_.c_str());

	  pid_t pid = fork();

	  if (pid < 0) 
	  {
		logger_->error("fork failed. %s", strerror(errno));
		return false;
	  } 
	  else if (pid > 0) 
	  {  // parent
		pid_ = pid;
		pidTracker_.add(pid);
		logger_->info("child pid is %d", pid);
		return true;
	  } 
	  else 
	  {  // child
		std::vector<char*> argv;

		for (const std::string& arg : argv_) 
		{
		  argv.push_back(const_cast<char*>(arg.c_str()));
		}
		argv.push_back(nullptr);

		execvp(exe_.c_str(), argv.data());
		logger_->error("execvp failed. %s", strerror(errno));
		abort();
	  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rdx
leaq 0x2728(%rip), %rsi      # 0x8220
callq 0x67d8
callq 0x30a0
movl %eax, %r14d
testl %eax, %eax
js 0x5b2b
je 0x5b61
movl %r14d, 0x60(%rbx)
movl %r14d, %esi
callq 0x5422
movq (%rbx), %rdi
leaq 0x2728(%rip), %rsi      # 0x8249
movl %r14d, %edx
callq 0x6704
jmp 0x5b4c
movq (%rbx), %rbx
callq 0x3040
movl (%rax), %edi
callq 0x30e0
leaq 0x26f8(%rip), %rsi      # 0x8239
movq %rbx, %rdi
movq %rax, %rdx
callq 0x68ac
testl %r14d, %r14d
setns %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x28(%rbx), %r12
movq 0x30(%rbx), %r13
cmpq %r13, %r12
je 0x5bb5
leaq -0x40(%rbp), %r14
leaq -0x48(%rbp), %r15
movq (%r12), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x5ba1
movq %rax, (%rsi)
addq $0x8, -0x38(%rbp)
jmp 0x5bac
movq %r14, %rdi
movq %r15, %rdx
callq 0x7312
addq $0x20, %r12
cmpq %r13, %r12
jne 0x5b85
leaq -0x48(%rbp), %rsi
movq $0x0, (%rsi)
leaq -0x40(%rbp), %rdi
callq 0x6946
movq 0x8(%rbx), %rdi
movq -0x40(%rbp), %rsi
callq 0x3280
movq (%rbx), %rbx
callq 0x3040
movl (%rax), %edi
callq 0x30e0
leaq 0x266d(%rip), %rsi      # 0x8259
movq %rbx, %rdi
movq %rax, %rdx
callq 0x68ac
callq 0x31e0
jmp 0x5c00
jmp 0x5c00
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x5c11
callq 0x3370
movq %rbx, %rdi
callq 0x3630
nop
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/watchdog.cpp
// Function: Program::resume()
bool Program::resume() 
	{
		  pidTracker_.dump("resume");

		  if (pid_t pid = pidTracker_.findMainPID(mainPidfile_)) 
		  {
			logger_->info("new main pid: %d", pid);
			pid_ = pid;
			return true;
		  }

		  const auto pids = pidTracker_.collectAll();
		  if (!pids.empty()) 
		  {
			pid_ = pids[0];
			return true;
		  }

		  return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x68, %rdi
leaq 0x40(%rbx), %rsi
callq 0x565e
testl %eax, %eax
je 0x5c56
movl %eax, %r14d
movq (%rbx), %rdi
leaq 0x25c9(%rip), %rsi      # 0x820f
movl %eax, %edx
callq 0x6704
movl %r14d, 0x60(%rbx)
movb $0x1, %r14b
jmp 0x5c7e
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x54ac
movq (%r14), %rdi
cmpq 0x8(%r14), %rdi
setne %r14b
je 0x5c74
movl (%rdi), %eax
movl %eax, 0x60(%rbx)
testq %rdi, %rdi
je 0x5c7e
callq 0x3370
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyufei95[P]watchdog_linux/watchdog.cpp
// Function: Supervisor::sighandler(int)
void Supervisor::sighandler(int signum) 
{
  if (self()->program_->pid()) 
  {
    self()->logger()->info(
        "Signal '%s' (%d) received. Forwarding to child PID %d.",
        strsignal(signum), signum, self()->program_->pid());

    // forward to child process
    self()->program_->signal(signum);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x5256(%rip), %r14      # 0xb3d8
movq 0x28(%r14), %rax
cmpl $0x0, 0x60(%rax)
je 0x61cf
movl %edi, %ebx
callq 0x3640
movq 0x523e(%rip), %rcx      # 0xb3d8
movq 0x28(%rcx), %rcx
movl 0x60(%rcx), %r8d
leaq 0x22f5(%rip), %rsi      # 0x849e
movq %r14, %rdi
movq %rax, %rdx
movl %ebx, %ecx
callq 0x6cd0
movq 0x521b(%rip), %rax      # 0xb3d8
movq 0x28(%rax), %rax
movl 0x60(%rax), %edi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x34f0
popq %rbx
popq %r14
popq %rbp
retq