LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/MemMang/heap_3.c
// Function: vPortFree
void vPortFree( void *pv )
{
	if( pv )
	{
		vTaskSuspendAll();
		{
			free( pv );
		}
		xTaskResumeAll();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x84d6
callq 0x4650
movq -0x8(%rbp), %rdi
callq 0x4060
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: pxPortInitialiseStack
portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )
{
/* Should actually keep this struct on the stack. */
xParams *pxThisThreadParams = pvPortMalloc( sizeof( xParams ) );

	(void)pthread_once( &hSigSetupThread, prvSetupSignalsAndSchedulerPolicy );

	if ( (pthread_t)NULL == hMainThread )
	{
		hMainThread = pthread_self();
	}

	/* No need to join the threads. */
	pthread_attr_init( &xThreadAttributes );
	pthread_attr_setdetachstate( &xThreadAttributes, PTHREAD_CREATE_DETACHED );

	/* Add the task parameters. */
	pxThisThreadParams->pxCode = pxCode;
	pxThisThreadParams->pvParams = pvParameters;

	vPortEnterCritical();

	lIndexOfLastAddedTask = prvGetFreeThreadState();

	/* Create the new pThread. */
	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
	{
		xSentinel = 0;
		if ( 0 != pthread_create( &( pxThreads[ lIndexOfLastAddedTask ].hThread ), &xThreadAttributes, prvWaitForStart, (void *)pxThisThreadParams ) )
		{
			/* Thread create failed, signal the failure */
			pxTopOfStack = 0;
		}

		/* Wait until the task suspends. */
		(void)pthread_mutex_unlock( &xSingleThreadMutex );
		while ( xSentinel == 0 );
		vPortExitCritical();
	}

	return pxTopOfStack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, %edi
callq 0x42f0
movq %rax, -0x20(%rbp)
leaq 0x637f(%rip), %rdi      # 0xe888
leaq 0xf0(%rip), %rsi        # 0x8600
callq 0x4780
xorl %eax, %eax
cmpq 0x6372(%rip), %rax      # 0xe890
jne 0x852c
callq 0x4570
movq %rax, 0x6364(%rip)      # 0xe890
leaq 0x6365(%rip), %rdi      # 0xe898
callq 0x42c0
leaq 0x6359(%rip), %rdi      # 0xe898
movl $0x1, %esi
callq 0x43d0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x4330
callq 0x87d0
movl %eax, 0x6360(%rip)      # 0xe8d0
leaq 0x6361(%rip), %rdi      # 0xe8d8
callq 0x47b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x85ec
movq $0x0, 0x6371(%rip) # 0xe900
movq 0x6372(%rip), %rdi      # 0xe908
movl 0x6334(%rip), %eax      # 0xe8d0
cltq
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rcx
leaq 0x62e8(%rip), %rsi      # 0xe898
leaq 0x289(%rip), %rdx       # 0x8840
callq 0x4550
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x85cc
movq $0x0, -0x8(%rbp)
leaq 0x6305(%rip), %rdi      # 0xe8d8
callq 0x4400
movq 0x6321(%rip), %rax      # 0xe900
cmpq $0x0, %rax
jne 0x85e7
jmp 0x85d8
callq 0x44a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvGetFreeThreadState
portLONG prvGetFreeThreadState( void )
{
portLONG lIndex;
	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
	{
		if ( pxThreads[ lIndex ].hThread == ( pthread_t )NULL )
		{
			break;
		}
	}

	if ( MAX_NUMBER_OF_TASKS == lIndex )
	{
		printf( "No more free threads, please increase the maximum.\n" );
		lIndex = 0;
		vPortEndScheduler();
	}

	return lIndex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x880c
movq 0x611c(%rip), %rax      # 0xe908
movslq -0x4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x87ff
jmp 0x880c
jmp 0x8801
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x87df
movl $0x40, %eax
cmpl -0x4(%rbp), %eax
jne 0x8830
leaq 0x2963(%rip), %rdi      # 0xb180
movb $0x0, %al
callq 0x4180
movl $0x0, -0x4(%rbp)
callq 0x44c0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvWaitForStart
void *prvWaitForStart( void * pvParams )
{
xParams * pxParams = ( xParams * )pvParams;
pdTASK_CODE pvCode = pxParams->pxCode;
void * pParams = pxParams->pvParams;
	vPortFree( pvParams );

	pthread_cleanup_push( prvDeleteThread, (void *)pthread_self() );

	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
	{
		prvSuspendThread( pthread_self() );
	}

	pvCode( pParams );

	pthread_cleanup_pop( 1 );
	return (void *)NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41a0
leaq 0xa22(%rip), %rax       # 0x92a0
movq %rax, -0x98(%rbp)
callq 0x4570
movq %rax, -0xa0(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
callq 0x4740
movl %eax, -0xa4(%rbp)
movslq -0xa4(%rbp), %rax
cmpq $0x0, %rax
je 0x88ce
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rdi
callq *%rax
leaq -0x90(%rbp), %rdi
callq 0x44e0
leaq -0x90(%rbp), %rdi
callq 0x46d0
leaq 0x5ff7(%rip), %rdi      # 0xe8d8
callq 0x47b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x88fb
callq 0x4570
movq %rax, %rdi
callq 0x8e80
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x8907
jmp 0x8909
leaq -0x90(%rbp), %rdi
callq 0x41d0
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rdi
callq *%rax
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: vPortExitCritical
void vPortExitCritical( void )
{
	/* Check for unmatched exits. */
	if ( uxCriticalNesting > 0 )
	{
		uxCriticalNesting--;
	}

	/* If we have reached 0 then re-enable the interrupts. */
	if( uxCriticalNesting == 0 )
	{
		/* Have we missed ticks? This is the equivalent of pending an interrupt. */
		if ( pdTRUE == xPendYield )
		{
			xPendYield = pdFALSE;
			vPortYield();
		}
		vPortEnableInterrupts();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5fd5(%rip), %rax      # 0xe910
cmpq $0x0, %rax
jbe 0x8953
movq 0x5fc8(%rip), %rax      # 0xe910
addq $-0x1, %rax
movq %rax, 0x5fbd(%rip)      # 0xe910
movq 0x5fb6(%rip), %rax      # 0xe910
cmpq $0x0, %rax
jne 0x8986
movq 0x5fe1(%rip), %rcx      # 0xe948
movl $0x1, %eax
cmpq %rcx, %rax
jne 0x8981
movq $0x0, 0x5fcc(%rip) # 0xe948
callq 0x4560
callq 0x43e0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvResumeThread
void prvResumeThread( pthread_t xThreadId )
{
portBASE_TYPE xResult;
	if ( 0 == pthread_mutex_lock( &xSuspendResumeThreadMutex ) )
	{
		if ( pthread_self() != xThreadId )
		{
			xResult = pthread_kill( xThreadId, SIG_RESUME );
		}
		xResult = pthread_mutex_unlock( &xSuspendResumeThreadMutex );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5f2d(%rip), %rdi      # 0xe920
callq 0x47b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8a31
callq 0x4570
cmpq -0x8(%rbp), %rax
je 0x8a1f
movq -0x8(%rbp), %rdi
movl $0xc, %esi
callq 0x42e0
cltq
movq %rax, -0x10(%rbp)
leaq 0x5efa(%rip), %rdi      # 0xe920
callq 0x4400
cltq
movq %rax, -0x10(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvGetThreadHandle
pthread_t prvGetThreadHandle( xTaskHandle hTask )
{
pthread_t hThread = ( pthread_t )NULL;
portLONG lIndex;
	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
	{
		if ( pxThreads[ lIndex ].hTask == hTask )
		{
			hThread = pxThreads[ lIndex ].hThread;
			break;
		}
	}
	return hThread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x8aa1
movq 0x5ea4(%rip), %rax      # 0xe908
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x8a94
movq 0x5e88(%rip), %rax      # 0xe908
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8aa1
jmp 0x8a96
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8a57
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: xPortStartScheduler
portBASE_TYPE xPortStartScheduler( void )
{
portBASE_TYPE xResult;
int iSignal;
sigset_t xSignals;
sigset_t xSignalToBlock;
sigset_t xSignalsBlocked;
portLONG lIndex;

	/* Establish the signals to block before they are needed. */
	sigfillset( &xSignalToBlock );

	/* Block until the end */
	(void)pthread_sigmask( SIG_SETMASK, &xSignalToBlock, &xSignalsBlocked );

	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
	{
		pxThreads[ lIndex ].uxCriticalNesting = 0;
	}

	/* Start the timer that generates the tick ISR.  Interrupts are disabled
	here already. */
	prvSetupTimerInterrupt();

	/* Start the first task. Will not return unless all threads are killed. */
	vPortStartFirstTask();

	/* This is the end signal we are looking for. */
	sigemptyset( &xSignals );
	sigaddset( &xSignals, SIG_RESUME );

	while ( pdTRUE != xSchedulerEnd )
	{
		if ( 0 != sigwait( &xSignals, &iSignal ) )
		{
			printf( "Main thread spurious signal: %d\n", iSignal );
		}
	}

	printf( "Cleaning Up, Exiting.\n" );
	/* Cleanup the mutexes */
	xResult = pthread_mutex_destroy( &xSuspendResumeThreadMutex );
	xResult = pthread_mutex_destroy( &xSingleThreadMutex );
	vPortFree( (void *)pxThreads );

	/* Should not get here! */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
leaq -0x110(%rbp), %rdi
callq 0x4350
movl $0x2, %edi
leaq -0x110(%rbp), %rsi
leaq -0x190(%rbp), %rdx
callq 0x44d0
movl $0x0, -0x194(%rbp)
cmpl $0x40, -0x194(%rbp)
jge 0x8b20
movq 0x5e0f(%rip), %rax      # 0xe908
movslq -0x194(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movl -0x194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
jmp 0x8ae9
callq 0x8bd0
callq 0x4480
leaq -0x90(%rbp), %rdi
callq 0x4300
leaq -0x90(%rbp), %rdi
movl $0xc, %esi
callq 0x4790
movq 0x5dca(%rip), %rcx      # 0xe918
movl $0x1, %eax
cmpq %rcx, %rax
je 0x8b83
leaq -0x90(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x4660
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x8b81
movl -0xc(%rbp), %esi
leaq 0x24c8(%rip), %rdi      # 0xb042
movb $0x0, %al
callq 0x4180
jmp 0x8b47
leaq 0x24d9(%rip), %rdi      # 0xb063
movb $0x0, %al
callq 0x4180
leaq 0x5d88(%rip), %rdi      # 0xe920
callq 0x41b0
cltq
movq %rax, -0x8(%rbp)
leaq 0x5d2e(%rip), %rdi      # 0xe8d8
callq 0x41b0
cltq
movq %rax, -0x8(%rbp)
movq 0x5d4c(%rip), %rdi      # 0xe908
callq 0x41a0
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvSetupTimerInterrupt
void prvSetupTimerInterrupt( void )
{
struct itimerval itimer, oitimer;
portTickType xMicroSeconds = portTICK_RATE_MICROSECONDS;

	/* Initialise the structure with the current timer information. */
	if ( 0 == getitimer( TIMER_TYPE, &itimer ) )
	{
		/* Set the interval between timer events. */
		itimer.it_interval.tv_sec = 0;
		itimer.it_interval.tv_usec = xMicroSeconds;

		/* Set the current count-down. */
		itimer.it_value.tv_sec = 0;
		itimer.it_value.tv_usec = xMicroSeconds;

		/* Set-up the timer interrupt. */
		if ( 0 != setitimer( TIMER_TYPE, &itimer, &oitimer ) )
		{
			printf( "Set Timer problem.\n" );
		}
	}
	else
	{
		printf( "Get Timer problem.\n" );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x3e8, -0x44(%rbp)     # imm = 0x3E8
xorl %edi, %edi
leaq -0x20(%rbp), %rsi
callq 0x4630
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8c37
movq $0x0, -0x20(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0x8(%rbp)
xorl %edi, %edi
leaq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4500
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x8c35
leaq 0x2489(%rip), %rdi      # 0xb0b7
movb $0x0, %al
callq 0x4180
jmp 0x8c45
leaq 0x248d(%rip), %rdi      # 0xb0cb
movb $0x0, %al
callq 0x4180
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: vPortEndScheduler
void vPortEndScheduler( void )
{
portBASE_TYPE xNumberOfThreads;
portBASE_TYPE xResult;
	for ( xNumberOfThreads = 0; xNumberOfThreads < MAX_NUMBER_OF_TASKS; xNumberOfThreads++ )
	{
		if ( ( pthread_t )NULL != pxThreads[ xNumberOfThreads ].hThread )
		{
			/* Kill all of the threads, they are in the detached state. */
			xResult = pthread_cancel( pxThreads[ xNumberOfThreads ].hThread );
		}
	}

	/* Signal the scheduler to exit its loop. */
	xSchedulerEnd = pdTRUE;
	(void)pthread_kill( hMainThread, SIG_RESUME );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x40, -0x8(%rbp)
jge 0x8caa
movq 0x5c9a(%rip), %rcx      # 0xe908
imulq $0x18, -0x8(%rbp), %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x8c9a
movq 0x5c84(%rip), %rax      # 0xe908
imulq $0x18, -0x8(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x4750
cltq
movq %rax, -0x10(%rbp)
jmp 0x8c9c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x8c60
movq $0x1, 0x5c63(%rip) # 0xe918
movq 0x5bd4(%rip), %rdi      # 0xe890
movl $0xc, %esi
callq 0x42e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: vPortYield
void vPortYield( void )
{
pthread_t xTaskToSuspend;
pthread_t xTaskToResume;

	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
	{
		xTaskToSuspend = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );

		vTaskSwitchContext();

		xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
		if ( xTaskToSuspend != xTaskToResume )
		{
			/* Remember and switch the critical nesting. */
			prvSetTaskCriticalNesting( xTaskToSuspend, uxCriticalNesting );
			uxCriticalNesting = prvGetTaskCriticalNesting( xTaskToResume );
			/* Switch tasks. */
			prvResumeThread( xTaskToResume );
			prvSuspendThread( xTaskToSuspend );
		}
		else
		{
			/* Yielding to self */
			(void)pthread_mutex_unlock( &xSingleThreadMutex );
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5bb9(%rip), %rdi      # 0xe8d8
callq 0x47b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8d9f
callq 0x40c0
movq %rax, %rdi
callq 0x8a40
movq %rax, -0x8(%rbp)
callq 0x4710
callq 0x40c0
movq %rax, %rdi
callq 0x8a40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x8d91
movq -0x8(%rbp), %rdi
movq 0x5ba8(%rip), %rsi      # 0xe910
callq 0x8db0
movq -0x10(%rbp), %rdi
callq 0x8e10
movq %rax, 0x5b93(%rip)      # 0xe910
movq -0x10(%rbp), %rdi
callq 0x89e0
movq -0x8(%rbp), %rdi
callq 0x8e80
jmp 0x8d9d
leaq 0x5b40(%rip), %rdi      # 0xe8d8
callq 0x4400
jmp 0x8d9f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvSetTaskCriticalNesting
void prvSetTaskCriticalNesting( pthread_t xThreadId, unsigned portBASE_TYPE uxNesting )
{
portLONG lIndex;
	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
	{
		if ( pxThreads[ lIndex ].hThread == xThreadId )
		{
			pxThreads[ lIndex ].uxCriticalNesting = uxNesting;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x8e0d
movq 0x5b38(%rip), %rax      # 0xe908
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x8e00
movq -0x10(%rbp), %rcx
movq 0x5b19(%rip), %rax      # 0xe908
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
jmp 0x8e0d
jmp 0x8e02
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8dc3
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvGetTaskCriticalNesting
unsigned portBASE_TYPE prvGetTaskCriticalNesting( pthread_t xThreadId )
{
unsigned portBASE_TYPE uxNesting = 0;
portLONG lIndex;
	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
	{
		if ( pxThreads[ lIndex ].hThread == xThreadId )
		{
			uxNesting = pxThreads[ lIndex ].uxCriticalNesting;
			break;
		}
	}
	return uxNesting;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x8e71
movq 0x5ad4(%rip), %rax      # 0xe908
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x8e64
movq 0x5ab9(%rip), %rax      # 0xe908
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8e71
jmp 0x8e66
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e27
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvSuspendThread
void prvSuspendThread( pthread_t xThreadId )
{
portBASE_TYPE xResult = pthread_mutex_lock( &xSuspendResumeThreadMutex );
	if ( 0 == xResult )
	{
		/* Set-up for the Suspend Signal handler? */
		xSentinel = 0;
		xResult = pthread_mutex_unlock( &xSuspendResumeThreadMutex );
		xResult = pthread_kill( xThreadId, SIG_SUSPEND );
		while ( ( xSentinel == 0 ) && ( pdTRUE != xServicingTick ) )
		{
			sched_yield();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5a8d(%rip), %rdi      # 0xe920
callq 0x47b0
cltq
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x8f10
movq $0x0, 0x5a4f(%rip) # 0xe900
leaq 0x5a68(%rip), %rdi      # 0xe920
callq 0x4400
cltq
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x42e0
cltq
movq %rax, -0x10(%rbp)
movq 0x5a22(%rip), %rcx      # 0xe900
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
jne 0x8efe
movq 0x5a60(%rip), %rcx      # 0xe950
movl $0x1, %eax
cmpq %rcx, %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x8f07
jmp 0x8f0e
callq 0x4290
jmp 0x8ed7
jmp 0x8f10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: vPortSystemTickHandler
void vPortSystemTickHandler( int sig )
{
pthread_t xTaskToSuspend;
pthread_t xTaskToResume;

	if ( ( pdTRUE == xInterruptsEnabled ) && ( pdTRUE != xServicingTick ) )
	{
		if ( 0 == pthread_mutex_trylock( &xSingleThreadMutex ) )
		{
			xServicingTick = pdTRUE;

			xTaskToSuspend = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
			/* Tick Increment. */
			vTaskIncrementTick();

			/* Select Next Task. */
#if ( configUSE_PREEMPTION == 1 )
			vTaskSwitchContext();
#endif
			xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );

			/* The only thread that can process this tick is the running thread. */
			if ( xTaskToSuspend != xTaskToResume )
			{
				/* Remember and switch the critical nesting. */
				prvSetTaskCriticalNesting( xTaskToSuspend, uxCriticalNesting );
				uxCriticalNesting = prvGetTaskCriticalNesting( xTaskToResume );
				/* Resume next task. */
				prvResumeThread( xTaskToResume );
				/* Suspend the current task. */
				prvSuspendThread( xTaskToSuspend );
			}
			else
			{
				/* Release the lock as we are Resuming. */
				(void)pthread_mutex_unlock( &xSingleThreadMutex );
			}
			xServicingTick = pdFALSE;
		}
		else
		{
			xPendYield = pdTRUE;
		}
	}
	else
	{
		xPendYield = pdTRUE;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x548e(%rip), %rcx      # 0xe400
movl $0x1, %eax
cmpq %rcx, %rax
jne 0x9048
movq 0x59c9(%rip), %rcx      # 0xe950
movl $0x1, %eax
cmpq %rcx, %rax
je 0x9048
leaq 0x593c(%rip), %rdi      # 0xe8d8
callq 0x4270
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x903b
movq $0x1, 0x5998(%rip) # 0xe950
callq 0x40c0
movq %rax, %rdi
callq 0x8a40
movq %rax, -0x10(%rbp)
callq 0x43f0
callq 0x4710
callq 0x40c0
movq %rax, %rdi
callq 0x8a40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x9022
movq -0x10(%rbp), %rdi
movq 0x5917(%rip), %rsi      # 0xe910
callq 0x8db0
movq -0x18(%rbp), %rdi
callq 0x8e10
movq %rax, 0x5902(%rip)      # 0xe910
movq -0x18(%rbp), %rdi
callq 0x89e0
movq -0x10(%rbp), %rdi
callq 0x8e80
jmp 0x902e
leaq 0x58af(%rip), %rdi      # 0xe8d8
callq 0x4400
movq $0x0, 0x5917(%rip) # 0xe950
jmp 0x9046
movq $0x1, 0x5902(%rip) # 0xe948
jmp 0x9053
movq $0x1, 0x58f5(%rip) # 0xe948
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: vPortForciblyEndThread
void vPortForciblyEndThread( void *pxTaskToDelete )
{
xTaskHandle hTaskToDelete = ( xTaskHandle )pxTaskToDelete;
pthread_t xTaskToDelete;
pthread_t xTaskToResume;
portBASE_TYPE xResult;

	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
	{
		xTaskToDelete = prvGetThreadHandle( hTaskToDelete );
		xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );

		if ( xTaskToResume == xTaskToDelete )
		{
			/* This is a suicidal thread, need to select a different task to run. */
			vTaskSwitchContext();
			xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
		}

		if ( pthread_self() != xTaskToDelete )
		{
			/* Cancelling a thread that is not me. */
			if ( xTaskToDelete != ( pthread_t )NULL )
			{
				/* Send a signal to wake the task so that it definitely cancels. */
				pthread_testcancel();
				xResult = pthread_cancel( xTaskToDelete );
				/* Pthread Clean-up function will note the cancellation. */
			}
			(void)pthread_mutex_unlock( &xSingleThreadMutex );
		}
		else
		{
			/* Resume the other thread. */
			prvResumeThread( xTaskToResume );
			/* Pthread Clean-up function will note the cancellation. */
			/* Release the execution. */
			uxCriticalNesting = 0;
			vPortEnableInterrupts();
			(void)pthread_mutex_unlock( &xSingleThreadMutex );
			/* Commit suicide */
			pthread_exit( (void *)1 );
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x585d(%rip), %rdi      # 0xe8d8
callq 0x47b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x912f
movq -0x10(%rbp), %rdi
callq 0x8a40
movq %rax, -0x18(%rbp)
callq 0x40c0
movq %rax, %rdi
callq 0x8a40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x90ca
callq 0x4710
callq 0x40c0
movq %rax, %rdi
callq 0x8a40
movq %rax, -0x20(%rbp)
callq 0x4570
cmpq -0x18(%rbp), %rax
je 0x90fe
cmpq $0x0, -0x18(%rbp)
je 0x90f0
callq 0x4340
movq -0x18(%rbp), %rdi
callq 0x4750
cltq
movq %rax, -0x28(%rbp)
leaq 0x57e1(%rip), %rdi      # 0xe8d8
callq 0x4400
jmp 0x912d
movq -0x20(%rbp), %rdi
callq 0x89e0
movq $0x0, 0x57fe(%rip) # 0xe910
callq 0x43e0
leaq 0x57ba(%rip), %rdi      # 0xe8d8
callq 0x4400
movl $0x1, %edi
callq 0x4410
jmp 0x912f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: vPortAddTaskHandle
void vPortAddTaskHandle( void *pxTaskHandle )
{
portLONG lIndex;

	pxThreads[ lIndexOfLastAddedTask ].hTask = ( xTaskHandle )pxTaskHandle;
	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
	{
		if ( pxThreads[ lIndex ].hThread == pxThreads[ lIndexOfLastAddedTask ].hThread )
		{
			if ( pxThreads[ lIndex ].hTask != pxThreads[ lIndexOfLastAddedTask ].hTask )
			{
				pxThreads[ lIndex ].hThread = ( pthread_t )NULL;
				pxThreads[ lIndex ].hTask = NULL;
				pxThreads[ lIndex ].uxCriticalNesting = 0;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x57b5(%rip), %rax      # 0xe908
movl 0x5777(%rip), %edx      # 0xe8d0
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x923f
movq 0x5789(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x5774(%rip), %rcx      # 0xe908
movl 0x5736(%rip), %edx      # 0xe8d0
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x922f
movq 0x5754(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x573e(%rip), %rcx      # 0xe908
movl 0x5700(%rip), %edx      # 0xe8d0
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
je 0x922d
movq 0x5721(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x5708(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x56ee(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
jmp 0x922f
jmp 0x9231
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x916e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvDeleteThread
void prvDeleteThread( void *xThreadId )
{
portLONG lIndex;
	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
	{
		if ( pxThreads[ lIndex ].hThread == ( pthread_t )xThreadId )
		{
			pxThreads[ lIndex ].hThread = (pthread_t)NULL;
			pxThreads[ lIndex ].hTask = (xTaskHandle)NULL;
			if ( pxThreads[ lIndex ].uxCriticalNesting > 0 )
			{
				uxCriticalNesting = 0;
				vPortEnableInterrupts();
			}
			pxThreads[ lIndex ].uxCriticalNesting = 0;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x9363
movq 0x5644(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9353
movq 0x5626(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x560d(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x55f3(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jbe 0x9337
movq $0x0, 0x55de(%rip) # 0xe910
callq 0x43e0
movq 0x55ca(%rip), %rax      # 0xe908
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
jmp 0x9363
jmp 0x9355
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x92b3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/portable/GCC/Posix/port.c
// Function: prvSuspendSignalHandler
void prvSuspendSignalHandler(int sig)
{
sigset_t xSignals;

	/* Only interested in the resume signal. */
	sigemptyset( &xSignals );
	sigaddset( &xSignals, SIG_RESUME );
	xSentinel = 1;

	/* Unlock the Single thread mutex to allow the resumed task to continue. */
	if ( 0 != pthread_mutex_unlock( &xSingleThreadMutex ) )
	{
		printf( "Releasing someone else's lock.\n" );
	}

	/* Wait on the resume signal. */
	if ( 0 != sigwait( &xSignals, &sig ) )
	{
		printf( "SSH: Sw %d\n", sig );
	}

	/* Will resume here when the SIG_RESUME signal is received. */
	/* Need to set the interrupts based on the task's critical nesting. */
	if ( uxCriticalNesting == 0 )
	{
		vPortEnableInterrupts();
	}
	else
	{
		vPortDisableInterrupts();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4300
leaq -0x88(%rbp), %rdi
movl $0xc, %esi
callq 0x4790
movq $0x1, 0x555a(%rip) # 0xe900
leaq 0x552b(%rip), %rdi      # 0xe8d8
callq 0x4400
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x93c8
leaq 0x1d93(%rip), %rdi      # 0xb154
movb $0x0, %al
callq 0x4180
leaq -0x88(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x4660
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x93f1
movl -0x4(%rbp), %esi
leaq 0x1d8a(%rip), %rdi      # 0xb174
movb $0x0, %al
callq 0x4180
movq 0x5518(%rip), %rax      # 0xe910
cmpq $0x0, %rax
jne 0x9405
callq 0x43e0
jmp 0x940a
callq 0x4320
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FileIO/fileIO.c
// Function: vDisplayMessage
void vDisplayMessage( const char * const pcMessageToPrint )
{
	vTaskSuspendAll();
	{
		printf( "%s", pcMessageToPrint );
		fflush( stdout );
	}
	xTaskResumeAll();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4650
movq -0x8(%rbp), %rsi
leaq 0x1d38(%rip), %rdi      # 0xb1b4
movb $0x0, %al
callq 0x4180
movq 0x4a36(%rip), %rax      # 0xdec0
movq (%rax), %rdi
callq 0x4430
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FileIO/fileIO.c
// Function: vWriteMessageToDisk
void vWriteMessageToDisk( const char * const pcMessage )
{
const portCHAR * const pcFileName = "RTOSlog.txt";
const portCHAR * const pcSeparator = "\r\n-----------------------\r\n";
FILE *pf;

	vTaskSuspendAll();
	{
		pf = fopen( pcFileName, "a" );
		if( pf != NULL )
		{
			fwrite( pcMessage, strlen( pcMessage ), ( unsigned portSHORT ) 1, pf );
			fwrite( pcSeparator, strlen( pcSeparator ), ( unsigned portSHORT ) 1, pf );
			fclose( pf );
		}
	}
	xTaskResumeAll();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1d04(%rip), %rax      # 0xb1b7
movq %rax, -0x10(%rbp)
leaq 0x1d05(%rip), %rax      # 0xb1c3
movq %rax, -0x18(%rbp)
callq 0x4650
leaq 0x1ce9(%rip), %rdi      # 0xb1b7
leaq 0x1d0a(%rip), %rsi      # 0xb1df
callq 0x4600
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x952e
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4160
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x46c0
movq -0x20(%rbp), %rcx
leaq 0x1cad(%rip), %rdi      # 0xb1c3
movl $0x1b, %esi
movl $0x1, %edx
callq 0x46c0
movq -0x20(%rbp), %rdi
callq 0x4140
callq 0x4080
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FileIO/fileIO.c
// Function: vWriteBufferToDisk
void vWriteBufferToDisk( const char * const pcBuffer, unsigned long ulBufferLength )
{
const portCHAR * const pcFileName = "trace.bin";
FILE *pf;

	vTaskSuspendAll();
	{
		pf = fopen( pcFileName, "wb" );
		if( pf )
		{
			fwrite( pcBuffer, ( size_t ) ulBufferLength, ( unsigned portSHORT ) 1, pf );
			fclose( pf );
		}
	}
	xTaskResumeAll();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1c8a(%rip), %rax      # 0xb1e1
movq %rax, -0x18(%rbp)
callq 0x4650
leaq 0x1c7a(%rip), %rdi      # 0xb1e1
leaq 0x1c7d(%rip), %rsi      # 0xb1eb
callq 0x4600
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x959d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x46c0
movq -0x20(%rbp), %rdi
callq 0x4140
callq 0x4080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIO.c
// Function: lAsyncIORegisterCallback
long lAsyncIORegisterCallback( int iFileDescriptor, void (*pvFunction)(int,void*), void *pvContext )
{
xAsyncIOCallback *pxIterator;
	if ( NULL != pvFunction )
	{
		/* Record the socket against its call back. */
		for ( pxIterator = &xHead; pxIterator->pxNext != NULL; pxIterator = pxIterator->pxNext );
		pxIterator->pxNext = ( xAsyncIOCallback * )malloc( sizeof( xAsyncIOCallback ) );
		pxIterator->pxNext->iFileHandle = iFileDescriptor;
		pxIterator->pxNext->pvFunction = pvFunction;
		pxIterator->pxNext->pvContext = pvContext;

		/* Set the socket as requiring a signal when messages are received. */
		prvRegisterSignalHandler( iFileDescriptor );
	}
	return ( NULL != pvFunction );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x963b
leaq 0x5386(%rip), %rax      # 0xe958
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x95f1
jmp 0x95e3
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x95d6
movl $0x20, %edi
callq 0x4420
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %edi
callq 0x47c0
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIO.c
// Function: prvRegisterSignalHandler
void prvRegisterSignalHandler( int iSocket )
{
struct sigaction xAction;

	if ( 1 != iAlreadyRegisteredHandler )
	{
		/* Initialise the sigaction struct for the signal handler. */
		xAction.sa_sigaction = prvSignalHandler;
		xAction.sa_flags = SA_SIGINFO;	/* Using this option, the signal handler knows which socket caused the signal. */
		sigfillset( &xAction.sa_mask );
		sigdelset( &xAction.sa_mask, SIG_MSG_RX );
		sigdelset( &xAction.sa_mask, SIG_TICK );

		/* Register the signal handler. */
		if ( 0 != sigaction( SIG_MSG_RX, &xAction, NULL ) )	/* Register the Signal Handler. */
		{
			printf( "Problem installing SIG_MSG_RX\n" );
		}
		else
		{
			iAlreadyRegisteredHandler = 1;
		}
	}

	/* Request that the socket generates a signal. */
	if ( SIG_MSG_RX == SIGIO )
	{
		if ( 0 != fcntl( iSocket, F_SETOWN, getpid() ) )
		{
			printf( "fnctl: Failed: %d\n", errno );
		}
	}
	else
	{
		/* Use real-time signals instead of SIGIO */
		if ( 0 != fcntl( iSocket, F_SETSIG, SIG_MSG_RX ) )
		{
			printf( "fnctl: Failed: %d\n", errno );
		}
	}

	/* Indicate that the socket is Asynchronous. */
	if ( 0 != fcntl( iSocket, F_SETFL, O_ASYNC ) )
	{
		printf( "fcntl: Failed: %d\n", errno );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movl 0x5304(%rip), %ecx      # 0xe978
movl $0x1, %eax
cmpl %ecx, %eax
je 0x9709
movq 0x4920(%rip), %rax      # 0xdfa8
movq %rax, -0xa0(%rbp)
movl $0x4, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x4350
leaq -0xa0(%rbp), %rdi
addq $0x8, %rdi
movl $0x1d, %esi
callq 0x4610
leaq -0xa0(%rbp), %rdi
addq $0x8, %rdi
movl $0xe, %esi
callq 0x4610
movl $0x1d, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x40e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x96fd
leaq 0x1b0c(%rip), %rdi      # 0xb200
movb $0x0, %al
callq 0x4180
jmp 0x9707
movl $0x1, 0x5271(%rip)      # 0xe978
jmp 0x9709
movl -0x4(%rbp), %eax
movl %eax, -0xa4(%rbp)
callq 0x4120
movl -0xa4(%rbp), %edi
movl %eax, %edx
movl $0x8, %esi
movb $0x0, %al
callq 0x4110
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x9748
callq 0x40a0
movl (%rax), %esi
leaq 0x1ade(%rip), %rdi      # 0xb21f
movb $0x0, %al
callq 0x4180
movl -0x4(%rbp), %edi
movl $0x4, %esi
movl $0x2000, %edx           # imm = 0x2000
movb $0x0, %al
callq 0x4110
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x9779
callq 0x40a0
movl (%rax), %esi
leaq 0x1ac0(%rip), %rdi      # 0xb232
movb $0x0, %al
callq 0x4180
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIO.c
// Function: vAsyncIOUnregisterCallback
void vAsyncIOUnregisterCallback( int iFileDescriptor )
{
xAsyncIOCallback *pxIterator;
xAsyncIOCallback *pxDelete;
	for ( pxIterator = &xHead; ( pxIterator->pxNext != NULL ) && ( pxIterator->pxNext->iFileHandle != iFileDescriptor ); pxIterator = pxIterator->pxNext );
	if ( pxIterator->pxNext != NULL )
	{
		if ( pxIterator->pxNext->iFileHandle == iFileDescriptor )
		{
			if ( pxIterator->pxNext->pxNext != NULL )
			{
				pxDelete = pxIterator->pxNext;
				pxIterator->pxNext = pxDelete->pxNext;
			}
			else
			{
				pxDelete = pxIterator->pxNext;
				pxIterator->pxNext = NULL;
			}
			free( pxDelete );
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x51b6(%rip), %rax      # 0xe958
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x19(%rbp)
je 0x97c9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x97d2
jmp 0x97e2
jmp 0x97d4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x97a6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x984c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x984a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x9829
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x9841
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x4060
jmp 0x984c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIOSerial.c
// Function: lAsyncIOSerialOpen
long lAsyncIOSerialOpen( const char *pcDevice, int *piDeviceDescriptor )
{
int iSerialDevice = 0;
struct termios xTerminalSettings;
long lReturn = pdFALSE;

	/* Open the port that was passed in. */
	iSerialDevice = open( pcDevice, O_RDWR | O_NOCTTY | O_NONBLOCK );
	if ( iSerialDevice < 0 )
	{
		lReturn = pdFALSE;
	}
	else
	{
		/* Grab a copy of the current terminal settings. */
		if ( 0 == tcgetattr( iSerialDevice, &xTerminalSettings ) )
		{
			/* Configure the port to the Hard-coded values. */
			cfmakeraw( &xTerminalSettings );
			cfsetspeed( &xTerminalSettings, B38400 );
			/* Set the terminal settings. */
			lReturn = ( 0 == tcsetattr(iSerialDevice, TCSANOW, &xTerminalSettings) );

			/* Pass out the device descriptor for subsequent calls to AsyncIORegisterCallback() */
			*piDeviceDescriptor = iSerialDevice;
		}
	}

	return lReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movl $0x902, %esi            # imm = 0x902
movb $0x0, %al
callq 0x45e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x99f2
movq $0x0, -0x58(%rbp)
jmp 0x9a4a
movl -0x14(%rbp), %edi
leaq -0x50(%rbp), %rsi
callq 0x45a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x9a48
leaq -0x50(%rbp), %rdi
callq 0x4510
leaq -0x50(%rbp), %rdi
movl $0xf, %esi
callq 0x4200
movl -0x14(%rbp), %edi
xorl %esi, %esi
leaq -0x50(%rbp), %rdx
callq 0x45b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x9a4a
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIOSerial.c
// Function: vAsyncSerialIODataAvailableISR
void vAsyncSerialIODataAvailableISR( int iFileDescriptor, void *pContext )
{
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
ssize_t iReadResult = -1;
unsigned char ucRx;

	/* This handler only processes a single byte/character at a time. */
	iReadResult = read( iFileDescriptor, &ucRx, 1 );
	if ( 1 == iReadResult )
	{
		if ( NULL != pContext )
		{
			/* Send the received byte to the queue. */
			if ( pdTRUE != xQueueSendFromISR( (xQueueHandle)pContext, &ucRx, &xHigherPriorityTaskWoken ) )
			{
				/* the queue is full. */
			}
		}
	}
	portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $-0x1, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x42a0
movq %rax, -0x20(%rbp)
movl $0x1, %eax
cmpq -0x20(%rbp), %rax
jne 0x9acf
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x9acd
movq -0x10(%rbp), %rdi
leaq -0x21(%rbp), %rsi
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x40f0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
je 0x9acb
jmp 0x9acb
jmp 0x9acd
jmp 0x9acf
cmpq $0x0, -0x18(%rbp)
je 0x9adb
callq 0x4460
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIOSocket.c
// Function: iSocketOpenUDP
int iSocketOpenUDP( void (*vSocketCallback)( int, void * ), void *pvContext, struct sockaddr_in *pxBindAddress )
{
int iSocket = 0;

	taskENTER_CRITICAL();
	{
		/* Open a new socket. */
		iSocket = socket( PF_INET, SOCK_DGRAM, IPPROTO_UDP );
		if ( 0 != iSocket )
		{
			/* Have we been passed a call back function that will deal with received messages? */
			if ( pdTRUE == lAsyncIORegisterCallback( iSocket, vSocketCallback, pvContext ) )
			{
				/* This is UDP so bind it passed listen address. */
				if ( NULL != pxBindAddress )
				{
					if ( 0 != bind( iSocket, ( struct sockaddr *)pxBindAddress, sizeof( struct sockaddr_in ) ) )
					{
						printf("Bind error: %d\n", errno );
					}
				}
			}
			else
			{
				/* Socket is being used as polled IO or for sending data. */
			}
		}
		else
		{
			printf( "Failed to open socket: %d.\n", errno );
		}
	}
	taskEXIT_CRITICAL();
	return iSocket;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x4330
movl $0x2, %esi
movl $0x11, %edx
movl %esi, %edi
callq 0x47d0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
je 0x9b8e
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4440
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
jne 0x9b8a
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x9b88
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x4540
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x9b86
callq 0x40a0
movl (%rax), %esi
leaq 0x16c6(%rip), %rdi      # 0xb245
movb $0x0, %al
callq 0x4180
jmp 0x9b88
jmp 0x9b8c
jmp 0x9b8c
jmp 0x9ba3
callq 0x40a0
movl (%rax), %esi
leaq 0x16b9(%rip), %rdi      # 0xb255
movb $0x0, %al
callq 0x4180
callq 0x44a0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIOSocket.c
// Function: iSocketUDPSendTo
int iSocketUDPSendTo( int iSocket, xUDPPacket *pxPacket, struct sockaddr_in *pxSendAddress )
{
int iBytesSent = 0;
	if ( ( 0 != iSocket ) && ( NULL != pxPacket ) )
	{
		taskENTER_CRITICAL();
			iBytesSent = sendto( iSocket, pxPacket, sizeof( xUDPPacket ), 0, ( struct sockaddr *)pxSendAddress, sizeof( struct sockaddr_in ) );
		taskEXIT_CRITICAL();
	}
	return iBytesSent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
je 0x9c4b
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x9c4b
callq 0x4330
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %r8
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x4210
movl %eax, -0x1c(%rbp)
callq 0x44a0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIOSocket.c
// Function: iSocketUDPReceiveISR
int iSocketUDPReceiveISR( int iSocket, xUDPPacket *pxPacket, struct sockaddr_in *pxReceiveAddress )
{
int iBytesReceived = 0;
socklen_t xSocketLength = sizeof( struct sockaddr_in );

	if ( 0 != iSocket )
	{
		iBytesReceived = recvfrom( iSocket, pxPacket, sizeof( xUDPPacket ), 0, ( struct sockaddr *)pxReceiveAddress, &xSocketLength );
		pxPacket->ucNull = 0;
	}
	return iBytesReceived;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x10, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
je 0x9cb9
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %r8
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
leaq -0x20(%rbp), %r9
callq 0x4470
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x3ff(%rax)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIOSocket.c
// Function: iSocketUDPReceiveFrom
int iSocketUDPReceiveFrom( int iSocket, xUDPPacket *pxPacket, struct sockaddr_in *pxReceiveAddress )
{
int iBytesReceived = 0;
socklen_t xSocketLength = sizeof( struct sockaddr_in );

	if ( 0 != iSocket )
	{
		taskENTER_CRITICAL();
			iBytesReceived = recvfrom( iSocket, pxPacket, sizeof( xUDPPacket ), 0, ( struct sockaddr *)pxReceiveAddress, &xSocketLength );
			pxPacket->ucNull = 0;
		taskEXIT_CRITICAL();
	}
	return iBytesReceived;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x10, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
je 0x9d33
callq 0x4330
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %r8
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
leaq -0x20(%rbp), %r9
callq 0x4470
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x3ff(%rax)
callq 0x44a0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/AsyncIO/AsyncIOSocket.c
// Function: vUDPReceiveAndDeliverCallback
void vUDPReceiveAndDeliverCallback( int iSocket, void *pvContext )
{
portBASE_TYPE xHigherTaskWoken = pdFALSE;
static xUDPPacket xPacket;
struct sockaddr_in xReceiveAddress;

	if ( sizeof( xUDPPacket ) == iSocketUDPReceiveISR( iSocket, &xPacket, &xReceiveAddress ) )
	{
		if ( pdPASS != xQueueSendFromISR( (xQueueHandle)pvContext, &xPacket, &xHigherTaskWoken ) )
		{
			printf( "UDP Rx failed\n" );
		}
	}
	else
	{
		printf( "UDP Rx failed: %d\n", errno );
	}
	portEND_SWITCHING_ISR( xHigherTaskWoken );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x4(%rbp), %edi
leaq 0x4c1b(%rip), %rsi      # 0xe97c
leaq -0x28(%rbp), %rdx
callq 0x4170
movslq %eax, %rcx
movl $0x400, %eax            # imm = 0x400
cmpq %rcx, %rax
jne 0x9dac
movq -0x10(%rbp), %rdi
leaq 0x4bfa(%rip), %rsi      # 0xe97c
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x40f0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
je 0x9daa
leaq 0x14ce(%rip), %rdi      # 0xb271
movb $0x0, %al
callq 0x4180
jmp 0x9dc1
callq 0x40a0
movl (%rax), %esi
leaq 0x14c6(%rip), %rdi      # 0xb280
movb $0x0, %al
callq 0x4180
cmpq $0x0, -0x18(%rbp)
je 0x9dcd
callq 0x4460
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)