LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: prvCopyDataToQueue
static void prvCopyDataToQueue( xQUEUE *pxQueue, const void *pvItemToQueue, portBASE_TYPE xPosition )
{
	if( pxQueue->uxItemSize == ( unsigned portBASE_TYPE ) 0 )
	{
		#if ( configUSE_MUTEXES == 1 )
		{
			if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
			{
				/* The mutex is no longer being held. */
				vTaskPriorityDisinherit( ( void * ) pxQueue->pxMutexHolder );
				pxQueue->pxMutexHolder = NULL;
			}
		}
		#endif
	}
	else if( xPosition == queueSEND_TO_BACK )
	{
		memcpy( ( void * ) pxQueue->pcWriteTo, pvItemToQueue, ( unsigned ) pxQueue->uxItemSize );
		pxQueue->pcWriteTo += pxQueue->uxItemSize;
		if( pxQueue->pcWriteTo >= pxQueue->pcTail )
		{
			pxQueue->pcWriteTo = pxQueue->pcHead;
		}
	}
	else
	{
		memcpy( ( void * ) pxQueue->pcReadFrom, pvItemToQueue, ( unsigned ) pxQueue->uxItemSize );
		pxQueue->pcReadFrom -= pxQueue->uxItemSize;
		if( pxQueue->pcReadFrom < pxQueue->pcHead )
		{
			pxQueue->pcReadFrom = ( pxQueue->pcTail - pxQueue->uxItemSize );
		}
	}

	++( pxQueue->uxMessagesWaiting );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rcx
testq %rcx, %rcx
je 0x5256
movq %rdx, %rax
movl %ecx, %edx
testq %rax, %rax
je 0x526c
movq 0x18(%rbx), %rdi
callq 0x4370
movq 0x18(%rbx), %rcx
movq 0x80(%rbx), %rax
subq %rax, %rcx
movq %rcx, 0x18(%rbx)
cmpq (%rbx), %rcx
jae 0x5291
negq %rax
addq 0x8(%rbx), %rax
movq %rax, 0x18(%rbx)
jmp 0x5291
cmpq $0x0, (%rbx)
jne 0x5291
movq 0x8(%rbx), %rdi
callq 0x43d0
andq $0x0, 0x8(%rbx)
jmp 0x5291
movq 0x10(%rbx), %rdi
callq 0x4370
movq 0x10(%rbx), %rax
addq 0x80(%rbx), %rax
movq %rax, 0x10(%rbx)
cmpq 0x8(%rbx), %rax
jb 0x5291
movq (%rbx), %rax
movq %rax, 0x10(%rbx)
incq 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: prvIsQueueFull
static signed portBASE_TYPE prvIsQueueFull( const xQueueHandle pxQueue )
{
signed portBASE_TYPE xReturn;

	taskENTER_CRITICAL();
		xReturn = ( pxQueue->uxMessagesWaiting == pxQueue->uxLength );
	taskEXIT_CRITICAL();

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4340
movq 0x70(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x78(%rbx), %rax
sete %r14b
callq 0x44b0
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: xQueueGenericSendFromISR
signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition )
{
signed portBASE_TYPE xReturn;
unsigned portBASE_TYPE uxSavedInterruptStatus;

	/* Similar to xQueueGenericSend, except we don't block if there is no room
	in the queue.  Also we don't directly wake a task that was blocked on a
	queue read, instead we return a flag to say whether a context switch is
	required or not (i.e. has a task with a higher priority than us been woken
	by this	post). */
	uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
	{
		if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
		{
			traceQUEUE_SEND_FROM_ISR( pxQueue );

			prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

			/* If the queue is locked we do not alter the event list.  This will
			be done when the queue is unlocked later. */
			if( pxQueue->xTxLock == queueUNLOCKED )
			{
				if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) )
				{
					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
					{
						/* The task waiting has a higher priority so record that a
						context	switch is required. */
						*pxHigherPriorityTaskWoken = pdTRUE;
					}
				}
			}
			else
			{
				/* Increment the lock count so the task that unlocks the queue
				knows that data was posted while it was locked. */
				++( pxQueue->xTxLock );
			}

			xReturn = pdPASS;
		}
		else
		{
			traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );
			xReturn = errQUEUE_FULL;
		}
	}
	portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
callq 0x41d0
movq %rax, %rbx
movq 0x70(%r12), %rax
cmpq 0x78(%r12), %rax
jae 0x53ca
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x520a
movq 0x90(%r12), %rax
cmpq $-0x1, %rax
je 0x53e7
incq %rax
movq %rax, 0x90(%r12)
pushq $0x1
popq %r15
jmp 0x53cd
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x4730
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %r15
cmpq $0x0, 0x48(%r12)
je 0x53cd
addq $0x48, %r12
movq %r12, %rdi
callq 0x4230
testq %rax, %rax
je 0x53cd
movq $0x1, (%r14)
jmp 0x53cd
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: prvCopyDataFromQueue
static void prvCopyDataFromQueue( xQUEUE * const pxQueue, const void *pvBuffer )
{
	if( pxQueue->uxQueueType != queueQUEUE_IS_MUTEX )
	{
		pxQueue->pcReadFrom += pxQueue->uxItemSize;
		if( pxQueue->pcReadFrom >= pxQueue->pcTail )
		{
			pxQueue->pcReadFrom = pxQueue->pcHead;
		}
		memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->pcReadFrom, ( unsigned ) pxQueue->uxItemSize );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testq %rax, %rax
je 0x5441
movq 0x80(%rdi), %rcx
movq 0x18(%rdi), %rdx
addq %rcx, %rdx
cmpq 0x8(%rdi), %rdx
cmovbq %rdx, %rax
movq %rax, 0x18(%rdi)
movl %ecx, %edx
movq %rsi, %rdi
movq %rax, %rsi
popq %rbp
jmp 0x4370
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: uxQueueMessagesWaiting
unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle pxQueue )
{
unsigned portBASE_TYPE uxReturn;

	taskENTER_CRITICAL();
		uxReturn = pxQueue->uxMessagesWaiting;
	taskEXIT_CRITICAL();

	return uxReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4340
movq 0x70(%rbx), %rbx
callq 0x44b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: xQueueCRSendFromISR
signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken )
{
	/* Cannot block within an ISR so if there is no space on the queue then
	exit without doing anything. */
	if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
	{
		prvCopyDataToQueue( pxQueue, pvItemToQueue, queueSEND_TO_BACK );

		/* We only want to wake one co-routine per ISR, so check that a
		co-routine has not already been woken. */
		if( !xCoRoutinePreviouslyWoken )
		{
			if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) )
			{
				if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
				{
					return pdTRUE;
				}
			}
		}
	}

	return xCoRoutinePreviouslyWoken;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
jae 0x56ae
movq %rdi, %r14
xorl %edx, %edx
callq 0x520a
testq %rbx, %rbx
je 0x56b6
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x48(%r14)
je 0x56ae
addq $0x48, %r14
movq %r14, %rdi
callq 0x46a0
testq %rax, %rax
je 0x56ae
pushq $0x1
popq %rbx
jmp 0x56ae
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: xQueueCRReceiveFromISR
signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxCoRoutineWoken )
{
signed portBASE_TYPE xReturn;

	/* We cannot block from an ISR, so check there is data available. If
	not then just leave without doing anything. */
	if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 )
	{
		/* Copy the data from the queue. */
		pxQueue->pcReadFrom += pxQueue->uxItemSize;
		if( pxQueue->pcReadFrom >= pxQueue->pcTail )
		{
			pxQueue->pcReadFrom = pxQueue->pcHead;
		}
		--( pxQueue->uxMessagesWaiting );
		memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->pcReadFrom, ( unsigned ) pxQueue->uxItemSize );

		if( !( *pxCoRoutineWoken ) )
		{
			if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) )
			{
				if( xCoRoutineRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
				{
					*pxCoRoutineWoken = pdTRUE;
				}
			}
		}

		xReturn = pdPASS;
	}
	else
	{
		xReturn = pdFAIL;
	}

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x70(%rdi)
je 0x5745
movq %rdx, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %rcx
movq 0x18(%rdi), %rax
addq %rcx, %rax
movq %rax, 0x18(%rdi)
cmpq 0x8(%rdi), %rax
jb 0x5709
movq (%r14), %rax
movq %rax, 0x18(%r14)
decq 0x70(%r14)
movl %ecx, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4370
pushq $0x1
popq %r15
cmpq $0x0, (%rbx)
jne 0x5748
cmpq $0x0, 0x20(%r14)
je 0x5748
addq $0x20, %r14
movq %r14, %rdi
callq 0x46a0
testq %rax, %rax
je 0x5748
movq $0x1, (%rbx)
jmp 0x5748
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: prvAllocateTCBAndStack
static tskTCB *prvAllocateTCBAndStack( unsigned short usStackDepth, portSTACK_TYPE *puxStackBuffer )
{
tskTCB *pxNewTCB;

	/* Allocate space for the TCB.  Where the memory comes from depends on
	the implementation of the port malloc function. */
	pxNewTCB = ( tskTCB * ) pvPortMalloc( sizeof( tskTCB ) );

	if( pxNewTCB != NULL )
	{
		/* Allocate space for the stack used by the task being created.
		The base of the stack memory stored in the TCB so the task can
		be deleted later if required. */
		pxNewTCB->pxStack = ( portSTACK_TYPE * ) pvPortMallocAligned( ( ( ( size_t )usStackDepth ) * sizeof( portSTACK_TYPE ) ), puxStackBuffer );

		if( pxNewTCB->pxStack == NULL )
		{
			/* Could not allocate the stack.  Delete the allocated TCB. */
			vPortFree( pxNewTCB );
			pxNewTCB = NULL;
		}
		else
		{
			/* Just to help debugging. */
			memset( pxNewTCB->pxStack, tskSTACK_FILL_BYTE, usStackDepth * sizeof( portSTACK_TYPE ) );
		}
	}

	return pxNewTCB;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
movl $0x98, %edi
callq 0x4300
testq %rax, %rax
je 0x5922
movq %rax, %rbx
testq %r14, %r14
je 0x58ec
movq %r14, 0x60(%rbx)
movzwl %r15w, %r15d
shll $0x3, %r15d
jmp 0x5908
movzwl %r15w, %r15d
shll $0x3, %r15d
movq %r15, %rdi
callq 0x4300
movq %rax, %r14
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x591a
movq %r14, %rdi
movl $0xa5, %esi
movq %r15, %rdx
callq 0x4200
jmp 0x5924
movq %rbx, %rdi
callq 0x41b0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: prvInitialiseTaskLists
static void prvInitialiseTaskLists( void )
{
unsigned portBASE_TYPE uxPriority;

	for( uxPriority = 0; uxPriority < configMAX_PRIORITIES; uxPriority++ )
	{
		vListInitialise( ( xList * ) &( pxReadyTasksLists[ uxPriority ] ) );
	}

	vListInitialise( ( xList * ) &xDelayedTaskList1 );
	vListInitialise( ( xList * ) &xDelayedTaskList2 );
	vListInitialise( ( xList * ) &xPendingReadyList );

	#if ( INCLUDE_vTaskDelete == 1 )
	{
		vListInitialise( ( xList * ) &xTasksWaitingTermination );
	}
	#endif

	#if ( INCLUDE_vTaskSuspend == 1 )
	{
		vListInitialise( ( xList * ) &xSuspendedTaskList );
	}
	#endif

	/* Start with pxDelayedTaskList using list1 and the pxOverflowDelayedTaskList
	using list2. */
	pxDelayedTaskList = &xDelayedTaskList1;
	pxOverflowDelayedTaskList = &xDelayedTaskList2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
movq 0x555f(%rip), %r14      # 0xaf10
cmpq $0x190, %rbx            # imm = 0x190
je 0x59c9
leaq (%rbx,%r14), %rdi
callq 0x43c0
addq $0x28, %rbx
jmp 0x59b1
movq 0x5578(%rip), %rbx      # 0xaf48
movq %rbx, %rdi
callq 0x43c0
movq 0x54c9(%rip), %r14      # 0xaea8
movq %r14, %rdi
callq 0x43c0
movq 0x55aa(%rip), %rdi      # 0xaf98
callq 0x43c0
movq 0x558e(%rip), %rdi      # 0xaf88
callq 0x43c0
movq 0x5502(%rip), %rdi      # 0xaf08
callq 0x43c0
movq 0x55ae(%rip), %rax      # 0xafc0
movq %rbx, (%rax)
movq 0x5544(%rip), %rax      # 0xaf60
movq %r14, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskDelete
void vTaskDelete( xTaskHandle pxTaskToDelete )
	{
	tskTCB *pxTCB;

		portENTER_CRITICAL();
		{
			/* Ensure a yield is performed if the current task is being
			deleted. */
			if( pxTaskToDelete == pxCurrentTCB )
			{
				pxTaskToDelete = NULL;
			}

			/* If null is passed in here then we are deleting ourselves. */
			pxTCB = prvGetTCBFromHandle( pxTaskToDelete );

			/* Remove task from the ready list and place in the	termination list.
			This will stop the task from be scheduled.  The idle task will check
			the termination list and free up any memory allocated by the
			scheduler for the TCB and stack. */
			vListRemove( &( pxTCB->xGenericListItem ) );

			/* Is the task waiting on an event also? */
			if( pxTCB->xEventListItem.pvContainer )
			{
				vListRemove( &( pxTCB->xEventListItem ) );
			}

			vListInsertEnd( ( xList * ) &xTasksWaitingTermination, &( pxTCB->xGenericListItem ) );

			/* Increment the ucTasksDeleted variable so the idle task knows
			there is a task that has been deleted and that it should therefore
			check the xTasksWaitingTermination list. */
			++uxTasksDeleted;

			/* Increment the uxTaskNumberVariable also so kernel aware debuggers
			can detect that the task lists need re-generating. */
			uxTaskNumber++;

			traceTASK_DELETE( pxTCB );
		}
		portEXIT_CRITICAL();

		/* Force a reschedule if we have just deleted the current task. */
		if( xSchedulerRunning != pdFALSE )
		{
			if( ( void * ) pxTaskToDelete == NULL )
			{
				portYIELD_WITHIN_API();
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4340
movq 0x5573(%rip), %rax      # 0xafb0
movq (%rax), %rcx
cmpq %rbx, %rcx
sete %cl
testq %rbx, %rbx
sete %r15b
orb %cl, %r15b
cmpb $0x1, %r15b
jne 0x5a59
movq (%rax), %rbx
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4040
cmpq $0x0, 0x50(%rbx)
je 0x5a75
leaq 0x30(%rbx), %rdi
callq 0x4040
movq 0x550c(%rip), %rdi      # 0xaf88
movq %r14, %rsi
callq 0x4760
movq 0x5405(%rip), %rax      # 0xae90
incq (%rax)
movq 0x549b(%rip), %rax      # 0xaf30
incq (%rax)
movq %rbx, %rdi
callq 0x45d0
callq 0x44b0
movq 0x54a4(%rip), %rax      # 0xaf50
cmpq $0x0, (%rax)
sete %al
xorb $0x1, %r15b
addq $0x8, %rsp
orb %al, %r15b
jne 0x5acb
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4570
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: uxTaskPriorityGet
unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask )
	{
	tskTCB *pxTCB;
	unsigned portBASE_TYPE uxReturn;

		portENTER_CRITICAL();
		{
			/* If null is passed in here then we are changing the
			priority of the calling function. */
			pxTCB = prvGetTCBFromHandle( pxTask );
			uxReturn = pxTCB->uxPriority;
		}
		portEXIT_CRITICAL();

		return uxReturn;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4340
testq %rbx, %rbx
jne 0x5d33
movq 0x5280(%rip), %rax      # 0xafb0
movq (%rax), %rbx
movq 0x58(%rbx), %rbx
callq 0x44b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskSuspend
void vTaskSuspend( xTaskHandle pxTaskToSuspend )
	{
	tskTCB *pxTCB;

		portENTER_CRITICAL();
		{
			/* Ensure a yield is performed if the current task is being
			suspended. */
			if( pxTaskToSuspend == pxCurrentTCB )
			{
				pxTaskToSuspend = NULL;
			}

			/* If null is passed in here then we are suspending ourselves. */
			pxTCB = prvGetTCBFromHandle( pxTaskToSuspend );

			traceTASK_SUSPEND( pxTCB );

			/* Remove task from the ready/delayed list and place in the	suspended list. */
			vListRemove( &( pxTCB->xGenericListItem ) );

			/* Is the task waiting on an event also? */
			if( pxTCB->xEventListItem.pvContainer )
			{
				vListRemove( &( pxTCB->xEventListItem ) );
			}

			vListInsertEnd( ( xList * ) &xSuspendedTaskList, &( pxTCB->xGenericListItem ) );
		}
		portEXIT_CRITICAL();

		/* We may have just suspended the current task. */
		if( ( void * ) pxTaskToSuspend == NULL )
		{
			portYIELD_WITHIN_API();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4340
movq 0x5188(%rip), %rax      # 0xafb0
movq (%rax), %rcx
cmpq %rbx, %rcx
sete %cl
testq %rbx, %rbx
sete %r15b
orb %cl, %r15b
cmpb $0x1, %r15b
jne 0x5e44
movq (%rax), %rbx
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4040
cmpq $0x0, 0x50(%rbx)
je 0x5e63
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x4040
movq 0x509e(%rip), %rdi      # 0xaf08
movq %r14, %rsi
callq 0x4760
callq 0x44b0
addq $0x8, %rsp
testb %r15b, %r15b
je 0x5e8b
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4570
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskResume
void vTaskResume( xTaskHandle pxTaskToResume )
	{
	tskTCB *pxTCB;

		/* Remove the task from whichever list it is currently in, and place
		it in the ready list. */
		pxTCB = ( tskTCB * ) pxTaskToResume;

		/* The parameter cannot be NULL as it is impossible to resume the
		currently executing task. */
		if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB ) )
		{
			portENTER_CRITICAL();
			{
				if( xTaskIsTaskSuspended( pxTCB ) == pdTRUE )
				{
					traceTASK_RESUME( pxTCB );

					/* As we are in a critical section we can access the ready
					lists even if the scheduler is suspended. */
					vListRemove(  &( pxTCB->xGenericListItem ) );
					prvAddTaskToReadyQueue( pxTCB );

					/* We may have just resumed a higher priority task. */
					if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
					{
						/* This yield may not cause the task just resumed to run, but
						will leave the lists in the correct state for the next yield. */
						portYIELD_WITHIN_API();
					}
				}
			}
			portEXIT_CRITICAL();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5f40
movq %rdi, %rbx
movq 0x50e4(%rip), %r15      # 0xafb0
movq (%r15), %rax
cmpq %rdi, %rax
je 0x5f40
callq 0x4340
movq 0x28(%rbx), %rax
cmpq 0x5024(%rip), %rax      # 0xaf08
jne 0x5f31
cmpq $0x0, 0x50(%rbx)
jne 0x5f31
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4040
movq 0x58(%rbx), %rax
movq 0x4fc4(%rip), %rcx      # 0xaec8
cmpq (%rcx), %rax
jbe 0x5f0c
movq %rax, (%rcx)
imulq $0x28, %rax, %rdi
addq 0x4ff9(%rip), %rdi      # 0xaf10
movq %r14, %rsi
callq 0x4760
movq 0x58(%rbx), %rax
movq (%r15), %rcx
cmpq 0x58(%rcx), %rax
jb 0x5f31
callq 0x4570
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x44b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: xTaskResumeFromISR
portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume )
	{
	portBASE_TYPE xYieldRequired = pdFALSE;
	tskTCB *pxTCB;

		pxTCB = ( tskTCB * ) pxTaskToResume;

		if( xTaskIsTaskSuspended( pxTCB ) == pdTRUE )
		{
			traceTASK_RESUME_FROM_ISR( pxTCB );

			if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )
			{
				xYieldRequired = ( pxTCB->uxPriority >= pxCurrentTCB->uxPriority );
				vListRemove(  &( pxTCB->xGenericListItem ) );
				prvAddTaskToReadyQueue( pxTCB );
			}
			else
			{
				/* We cannot access the delayed or ready lists, so will hold this
				task pending until the scheduler is resumed, at which point a
				yield will be performed if necessary. */
				vListInsertEnd( ( xList * ) &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
			}
		}

		return xYieldRequired;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
cmpq 0x4fa8(%rip), %rax      # 0xaf08
jne 0x5f8c
movq %rdi, %r14
cmpq $0x0, 0x50(%rdi)
jne 0x5f8c
movq 0x4ff5(%rip), %rax      # 0xaf68
cmpq $0x0, (%rax)
je 0x5f9c
addq $0x30, %r14
movq 0x5014(%rip), %rdi      # 0xaf98
movq %r14, %rsi
callq 0x4760
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x58(%r14), %rax
movq 0x5009(%rip), %rcx      # 0xafb0
movq (%rcx), %rcx
xorl %ebx, %ebx
cmpq 0x58(%rcx), %rax
setae %bl
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x4040
movq 0x58(%r14), %rax
movq 0x4efe(%rip), %rcx      # 0xaec8
cmpq (%rcx), %rax
jbe 0x5fd2
movq %rax, (%rcx)
imulq $0x28, %rax, %rdi
addq 0x4f33(%rip), %rdi      # 0xaf10
movq %r15, %rsi
callq 0x4760
jmp 0x5f8e
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskIncrementTick
void vTaskIncrementTick( void )
{
	/* Called by the portable layer each time a tick interrupt occurs.
	Increments the tick then checks to see if the new tick value will cause any
	tasks to be unblocked. */
	if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )
	{
		++xTickCount;
		if( xTickCount == ( portTickType ) 0 )
		{
			xList *pxTemp;

			/* Tick count has overflowed so we need to swap the delay lists.
			If there are any items in pxDelayedTaskList here then there is
			an error! */
			pxTemp = pxDelayedTaskList;
			pxDelayedTaskList = pxOverflowDelayedTaskList;
			pxOverflowDelayedTaskList = pxTemp;
			xNumOfOverflows++;
		}

		/* See if this tick has made a timeout expire. */
		prvCheckDelayedTasks();
	}
	else
	{
		++uxMissedTicks;

		/* The tick hook gets called at regular intervals, even if the
		scheduler is locked. */
		#if ( configUSE_TICK_HOOK == 1 )
		{
			extern void vApplicationTickHook( void );

			vApplicationTickHook();
		}
		#endif
	}

	#if ( configUSE_TICK_HOOK == 1 )
	{
		extern void vApplicationTickHook( void );

		/* Guard against the tick hook being called when the missed tick
		count is being unwound (when the scheduler is being unlocked. */
		if( uxMissedTicks == 0 )
		{
			vApplicationTickHook();
		}
	}
	#endif

	traceTASK_INCREMENT_TICK( xTickCount );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x4ec5(%rip), %rax      # 0xaf68
cmpq $0x0, (%rax)
je 0x60c2
movq 0x4ed0(%rip), %rax      # 0xaf80
incq (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4e17(%rip), %rax      # 0xaee0
incl (%rax)
cmpl $0x0, (%rax)
jne 0x60f4
movq 0x4ee9(%rip), %rax      # 0xafc0
movq (%rax), %rcx
movq 0x4e7f(%rip), %rdx      # 0xaf60
movq (%rdx), %rsi
movq %rsi, (%rax)
movq %rcx, (%rdx)
movq 0x4ef7(%rip), %rax      # 0xafe8
incq (%rax)
movq 0x4ec5(%rip), %r15      # 0xafc0
movq 0x4dc6(%rip), %r12      # 0xaec8
movq 0x4e07(%rip), %r13      # 0xaf10
movq (%r15), %rax
cmpq $0x0, (%rax)
je 0x60b3
movq (%r15), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %r14
testq %r14, %r14
je 0x60b3
movq 0x4db7(%rip), %rax      # 0xaee0
movl (%rax), %eax
cmpl 0x8(%r14), %eax
jb 0x60b3
leaq 0x8(%r14), %rbx
movq %rbx, %rdi
callq 0x4040
cmpq $0x0, 0x50(%r14)
je 0x614d
leaq 0x30(%r14), %rdi
callq 0x4040
movq 0x58(%r14), %rax
cmpq (%r12), %rax
jbe 0x615b
movq %rax, (%r12)
imulq $0x28, %rax, %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x4760
jmp 0x6109
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: xTaskGetTickCount
portTickType xTaskGetTickCount( void )
{
portTickType xTicks;

	/* Critical section required if running on a 16 bit processor. */
	portENTER_CRITICAL();
	{
		xTicks = xTickCount;
	}
	portEXIT_CRITICAL();

	return xTicks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x4340
movq 0x4d62(%rip), %rax      # 0xaee0
movl (%rax), %ebx
callq 0x44b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskList
void vTaskList( signed char *pcWriteBuffer )
	{
	unsigned portBASE_TYPE uxQueue;

		/* This is a VERY costly function that should be used for debug only.
		It leaves interrupts disabled for a LONG time. */

		vTaskSuspendAll();
		{
			/* Run through all the lists that could potentially contain a TCB and
			report the task name, state and stack high water mark. */

			pcWriteBuffer[ 0 ] = ( signed char ) 0x00;
			strcat( ( char * ) pcWriteBuffer, ( const char * ) "\r\n" );

			uxQueue = uxTopUsedPriority + 1;

			do
			{
				uxQueue--;

				if( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) )
				{
					prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &( pxReadyTasksLists[ uxQueue ] ), tskREADY_CHAR );
				}
			}while( uxQueue > ( unsigned short ) tskIDLE_PRIORITY );

			if( !listLIST_IS_EMPTY( pxDelayedTaskList ) )
			{
				prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) pxDelayedTaskList, tskBLOCKED_CHAR );
			}

			if( !listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) )
			{
				prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) pxOverflowDelayedTaskList, tskBLOCKED_CHAR );
			}

			#if( INCLUDE_vTaskDelete == 1 )
			{
				if( !listLIST_IS_EMPTY( &xTasksWaitingTermination ) )
				{
					prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, tskDELETED_CHAR );
				}
			}
			#endif

			#if ( INCLUDE_vTaskSuspend == 1 )
			{
				if( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )
				{
					prvListTaskWithinSingleList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, tskSUSPENDED_CHAR );
				}
			}
			#endif
		}
		xTaskResumeAll();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x4db8(%rip), %rax      # 0xaf68
incq (%rax)
movq %rdi, %rbx
xorl %r14d, %r14d
movb %r14b, (%rdi)
callq 0x4170
movb %r14b, 0x2(%rbx,%rax)
movw $0xa0d, (%rbx,%rax)     # imm = 0xA0D
movq 0x4de5(%rip), %rax      # 0xafb8
movq (%rax), %r12
imulq $0x28, %r12, %r14
incq %r12
addq 0x4d2c(%rip), %r14      # 0xaf10
pushq $0x52
popq %r15
cmpq $0x0, (%r14)
je 0x61fc
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x46e0
decq %r12
addq $-0x28, %r14
testq %r12, %r12
jne 0x61e8
movq 0x4db1(%rip), %rax      # 0xafc0
movq (%rax), %rcx
cmpq $0x0, (%rcx)
je 0x6226
movq (%rax), %rsi
pushq $0x42
popq %rdx
movq %rbx, %rdi
callq 0x46e0
movq 0x4d33(%rip), %rax      # 0xaf60
movq (%rax), %rcx
cmpq $0x0, (%rcx)
je 0x6244
movq (%rax), %rsi
pushq $0x42
popq %rdx
movq %rbx, %rdi
callq 0x46e0
movq 0x4d3d(%rip), %rax      # 0xaf88
cmpq $0x0, (%rax)
je 0x6263
movq 0x4d30(%rip), %rsi      # 0xaf88
pushq $0x44
popq %rdx
movq %rbx, %rdi
callq 0x46e0
movq 0x4c9e(%rip), %rax      # 0xaf08
cmpq $0x0, (%rax)
je 0x6282
movq 0x4c91(%rip), %rsi      # 0xaf08
pushq $0x53
popq %rdx
movq %rbx, %rdi
callq 0x46e0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4080
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: prvListTaskWithinSingleList
static void prvListTaskWithinSingleList( const signed char *pcWriteBuffer, xList *pxList, signed char cStatus )
	{
	volatile tskTCB *pxNextTCB, *pxFirstTCB;
	unsigned short usStackRemaining;

		/* Write the details of all the TCB's in pxList into the buffer. */
		listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );
		do
		{
			listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );
			#if ( portSTACK_GROWTH > 0 )
			{
				usStackRemaining = usTaskCheckFreeStackSpace( ( unsigned char * ) pxNextTCB->pxEndOfStack );
			}
			#else
			{
				usStackRemaining = usTaskCheckFreeStackSpace( ( unsigned char * ) pxNextTCB->pxStack );
			}
			#endif			
			
			sprintf( pcStatusString, ( char * ) "%s\t\t%c\t%u\t%u\t%u\r\n", pxNextTCB->pcTaskName, cStatus, ( unsigned int ) pxNextTCB->uxPriority, usStackRemaining, ( unsigned int ) pxNextTCB->uxTCBNumber );
			strcat( ( char * ) pcWriteBuffer, ( char * ) pcStatusString );

		} while( pxNextTCB != pxFirstTCB );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0x10(%rsi), %rcx
movq %rcx, -0x30(%rbp)
cmpq %rcx, %rax
jne 0x62c8
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rax), %r14
movsbl %dl, %r15d
movq 0x4d19(%rip), %r12      # 0xaff0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
cmpq -0x30(%rbp), %rax
jne 0x62f1
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rax), %r13
movq 0x60(%r13), %rdi
callq 0x47a0
leaq 0x68(%r13), %rdx
movq 0x58(%r13), %r8
movzwl %ax, %r9d
movq 0x78(%r13), %rax
movl %eax, (%rsp)
movq %r12, %rdi
leaq 0x1cea(%rip), %rsi      # 0x8005
movl %r15d, %ecx
xorl %eax, %eax
callq 0x46b0
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x4680
cmpq %r14, %r13
jne 0x62d7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskGetRunTimeStats
void vTaskGetRunTimeStats( signed char *pcWriteBuffer )
	{
	unsigned portBASE_TYPE uxQueue;
	unsigned long ulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();

		/* This is a VERY costly function that should be used for debug only.
		It leaves interrupts disabled for a LONG time. */

		vTaskSuspendAll();
		{
			/* Run through all the lists that could potentially contain a TCB,
			generating a table of run timer percentages in the provided
			buffer. */

			pcWriteBuffer[ 0 ] = ( signed char ) 0x00;
			strcat( ( char * ) pcWriteBuffer, ( const char * ) "\r\n" );

			uxQueue = uxTopUsedPriority + 1;

			do
			{
				uxQueue--;

				if( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxQueue ] ) ) )
				{
					prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &( pxReadyTasksLists[ uxQueue ] ), ulTotalRunTime );
				}
			}while( uxQueue > ( unsigned short ) tskIDLE_PRIORITY );

			if( !listLIST_IS_EMPTY( pxDelayedTaskList ) )
			{
				prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) pxDelayedTaskList, ulTotalRunTime );
			}

			if( !listLIST_IS_EMPTY( pxOverflowDelayedTaskList ) )
			{
				prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) pxOverflowDelayedTaskList, ulTotalRunTime );
			}

			#if ( INCLUDE_vTaskDelete == 1 )
			{
				if( !listLIST_IS_EMPTY( &xTasksWaitingTermination ) )
				{
					prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xTasksWaitingTermination, ulTotalRunTime );
				}
			}
			#endif

			#if ( INCLUDE_vTaskSuspend == 1 )
			{
				if( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )
				{
					prvGenerateRunTimeStatsForTasksInList( pcWriteBuffer, ( xList * ) &xSuspendedTaskList, ulTotalRunTime );
				}
			}
			#endif
		}
		xTaskResumeAll();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x44a0
movq 0x4c09(%rip), %rcx      # 0xaf68
incq (%rcx)
movq %rax, %r14
xorl %r15d, %r15d
movb %r15b, (%rbx)
movq %rbx, %rdi
callq 0x4170
movb %r15b, 0x2(%rbx,%rax)
movw $0xa0d, (%rbx,%rax)     # imm = 0xA0D
movq 0x4c33(%rip), %rax      # 0xafb8
movq (%rax), %r12
imulq $0x28, %r12, %r15
incq %r12
addq 0x4b7a(%rip), %r15      # 0xaf10
cmpq $0x0, (%r15)
je 0x63aa
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4590
decq %r12
addq $-0x28, %r15
testq %r12, %r12
jne 0x6396
movq 0x4c03(%rip), %rax      # 0xafc0
movq (%rax), %rcx
cmpq $0x0, (%rcx)
je 0x63d4
movq (%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4590
movq 0x4b85(%rip), %rax      # 0xaf60
movq (%rax), %rcx
cmpq $0x0, (%rcx)
je 0x63f2
movq (%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4590
movq 0x4b8f(%rip), %rax      # 0xaf88
cmpq $0x0, (%rax)
je 0x6411
movq 0x4b82(%rip), %rsi      # 0xaf88
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4590
movq 0x4af0(%rip), %rax      # 0xaf08
cmpq $0x0, (%rax)
je 0x6430
movq 0x4ae3(%rip), %rsi      # 0xaf08
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4590
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4080
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: prvGenerateRunTimeStatsForTasksInList
static void prvGenerateRunTimeStatsForTasksInList( const signed char *pcWriteBuffer, xList *pxList, unsigned long ulTotalRunTime )
	{
	volatile tskTCB *pxNextTCB, *pxFirstTCB;
	unsigned long ulStatsAsPercentage;

		/* Write the run time stats of all the TCB's in pxList into the buffer. */
		listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );
		do
		{
			/* Get next TCB in from the list. */
			listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );

			/* Divide by zero check. */
			if( ulTotalRunTime > 0UL )
			{
				/* Has the task run at all? */
				if( pxNextTCB->ulRunTimeCounter == 0 )
				{
					/* The task has used no CPU time at all. */
					sprintf( pcStatsString, ( char * ) "%s\t\t0\t\t0%%\r\n", pxNextTCB->pcTaskName );
				}
				else
				{
					/* What percentage of the total run time as the task used?
					This will always be rounded down to the nearest integer. */
					ulStatsAsPercentage = ( 100UL * pxNextTCB->ulRunTimeCounter ) / ulTotalRunTime;

					if( ulStatsAsPercentage > 0UL )
					{
						sprintf( pcStatsString, ( char * ) "%s\t\t%u\t\t%u%%\r\n", pxNextTCB->pcTaskName, ( unsigned int ) pxNextTCB->ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage );
					}
					else
					{
						/* If the percentage is zero here then the task has
						consumed less than 1% of the total run time. */
						sprintf( pcStatsString, ( char * ) "%s\t\t%u\t\t<1%%\r\n", pxNextTCB->pcTaskName, ( unsigned int ) pxNextTCB->ulRunTimeCounter );
					}
				}

				strcat( ( char * ) pcWriteBuffer, ( char * ) pcStatsString );
			}

		} while( pxNextTCB != pxFirstTCB );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0x10(%rsi), %rcx
movq %rcx, -0x38(%rbp)
cmpq %rcx, %rax
jne 0x6479
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
movq 0x18(%rax), %r15
movq 0x4a14(%rip), %r13      # 0xae98
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
cmpq -0x38(%rbp), %rax
jne 0x649e
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
movq 0x18(%rax), %r12
testq %rbx, %rbx
je 0x652e
cmpq $0x0, 0x90(%r12)
je 0x64e4
imulq $0x64, 0x90(%r12), %rax
cmpq %rbx, %rax
jae 0x64fc
leaq 0x68(%r12), %rdx
movq 0x90(%r12), %rcx
movq %r13, %rdi
leaq 0x1b58(%rip), %rsi      # 0x8033
xorl %eax, %eax
callq 0x46b0
jmp 0x6522
leaq 0x68(%r12), %rdx
movq %r13, %rdi
leaq 0x1b24(%rip), %rsi      # 0x8017
xorl %eax, %eax
callq 0x46b0
jmp 0x6522
xorl %edx, %edx
divq %rbx
leaq 0x68(%r12), %rdx
movq 0x90(%r12), %rcx
movq %r13, %rdi
leaq 0x1b0c(%rip), %rsi      # 0x8024
movl %eax, %r8d
xorl %eax, %eax
callq 0x46b0
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x4680
cmpq %r15, %r12
jne 0x6484
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskStartTrace
void vTaskStartTrace( signed char * pcBuffer, unsigned long ulBufferSize )
	{
		portENTER_CRITICAL();
		{
			pcTraceBuffer = ( signed char * )pcBuffer;
			pcTraceBufferStart = pcBuffer;
			pcTraceBufferEnd = pcBuffer + ( ulBufferSize - tskSIZE_OF_EACH_TRACE_LINE );
			xTracing = pdTRUE;
		}
		portEXIT_CRITICAL();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4340
movq 0x49a1(%rip), %rax      # 0xaf00
movq %r14, (%rax)
movq 0x4a6f(%rip), %rax      # 0xafd8
movq %r14, (%rax)
leaq -0x10(%r14,%rbx), %rax
movq 0x4980(%rip), %rcx      # 0xaef8
movq %rax, (%rcx)
movq 0x49d6(%rip), %rax      # 0xaf58
movq $0x1, (%rax)
popq %rbx
popq %r14
popq %rbp
jmp 0x44b0
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: ulTaskEndTrace
unsigned long ulTaskEndTrace( void )
	{
	unsigned long ulBufferLength;

		portENTER_CRITICAL();
			xTracing = pdFALSE;
		portEXIT_CRITICAL();

		ulBufferLength = ( unsigned long ) ( pcTraceBuffer - pcTraceBufferStart );

		return ulBufferLength;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4340
movq 0x49b6(%rip), %rax      # 0xaf58
andq $0x0, (%rax)
callq 0x44b0
movq 0x494e(%rip), %rax      # 0xaf00
movq (%rax), %rax
movq 0x4a1c(%rip), %rcx      # 0xafd8
subq (%rcx), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskCleanUpResources
void vTaskCleanUpResources( void )
	{
	unsigned short usQueue;
	volatile tskTCB *pxTCB;

		usQueue = ( unsigned short ) uxTopUsedPriority + ( unsigned short ) 1;

		/* Remove any TCB's from the ready queues. */
		do
		{
			usQueue--;

			while( !listLIST_IS_EMPTY( &( pxReadyTasksLists[ usQueue ] ) ) )
			{
				listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &( pxReadyTasksLists[ usQueue ] ) );
				vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );

				prvDeleteTCB( ( tskTCB * ) pxTCB );
			}
		}while( usQueue > ( unsigned short ) tskIDLE_PRIORITY );

		/* Remove any TCB's from the delayed queue. */
		while( !listLIST_IS_EMPTY( &xDelayedTaskList1 ) )
		{
			listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList1 );
			vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );

			prvDeleteTCB( ( tskTCB * ) pxTCB );
		}

		/* Remove any TCB's from the overflow delayed queue. */
		while( !listLIST_IS_EMPTY( &xDelayedTaskList2 ) )
		{
			listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xDelayedTaskList2 );
			vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );

			prvDeleteTCB( ( tskTCB * ) pxTCB );
		}

		while( !listLIST_IS_EMPTY( &xSuspendedTaskList ) )
		{
			listGET_OWNER_OF_NEXT_ENTRY( pxTCB, &xSuspendedTaskList );
			vListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) );

			prvDeleteTCB( ( tskTCB * ) pxTCB );
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x49e2(%rip), %rax      # 0xafb8
movl (%rax), %r14d
incl %r14d
movq 0x492d(%rip), %r15      # 0xaf10
decl %r14d
movzwl %r14w, %eax
imulq $0x28, %rax, %rax
leaq (%r15,%rax), %r12
leaq (%r15,%rax), %r13
addq $0x10, %r13
cmpq $0x0, (%r12)
je 0x6634
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%r12)
cmpq %r13, %rax
jne 0x661d
movq 0x8(%rax), %rax
movq %rax, 0x8(%r12)
movq 0x18(%rax), %rbx
leaq 0x8(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
callq 0x4110
jmp 0x65fa
testw %r14w, %r14w
jne 0x65e3
movq 0x4907(%rip), %r14      # 0xaf48
leaq 0x10(%r14), %r15
cmpq $0x0, (%r14)
je 0x667b
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
cmpq %r15, %rax
jne 0x6664
movq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq 0x18(%rax), %rbx
leaq 0x8(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
callq 0x4110
jmp 0x6645
movq 0x4826(%rip), %r14      # 0xaea8
leaq 0x10(%r14), %r15
cmpq $0x0, (%r14)
je 0x66bc
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
cmpq %r15, %rax
jne 0x66a5
movq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq 0x18(%rax), %rbx
leaq 0x8(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
callq 0x4110
jmp 0x6686
movq 0x4845(%rip), %r14      # 0xaf08
leaq 0x10(%r14), %r15
cmpq $0x0, (%r14)
je 0x66fd
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
cmpq %r15, %rax
jne 0x66e6
movq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq 0x18(%rax), %rbx
leaq 0x8(%rbx), %rdi
callq 0x4040
movq %rbx, %rdi
callq 0x4110
jmp 0x66c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskSwitchContext
void vTaskSwitchContext( void )
{
	if( uxSchedulerSuspended != ( unsigned portBASE_TYPE ) pdFALSE )
	{
		/* The scheduler is currently suspended - do not allow a context
		switch. */
		xMissedYield = pdTRUE;
		return;
	}

	traceTASK_SWITCHED_OUT();

	#if ( configGENERATE_RUN_TIME_STATS == 1 )
	{
		unsigned long ulTempCounter = portGET_RUN_TIME_COUNTER_VALUE();

			/* Add the amount of time the task has been running to the accumulated
			time so far.  The time the task started running was stored in
			ulTaskSwitchedInTime.  Note that there is no overflow protection here
			so count values are only valid until the timer overflows.  Generally
			this will be about 1 hour assuming a 1uS timer increment. */
			pxCurrentTCB->ulRunTimeCounter += ( ulTempCounter - ulTaskSwitchedInTime );
			ulTaskSwitchedInTime = ulTempCounter;
	}
	#endif

	taskFIRST_CHECK_FOR_STACK_OVERFLOW();
	taskSECOND_CHECK_FOR_STACK_OVERFLOW();

	/* Find the highest priority queue that contains ready tasks. */
	while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopReadyPriority ] ) ) )
	{
		--uxTopReadyPriority;
	}

	/* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the tasks of the
	same priority get an equal share of the processor time. */
	listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopReadyPriority ] ) );

	traceTASK_SWITCHED_IN();
	vWriteTraceToBuffer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x47a4(%rip), %rax      # 0xaf68
cmpq $0x0, (%rax)
je 0x67da
movq 0x4707(%rip), %rax      # 0xaed8
movq $0x1, (%rax)
popq %rbp
retq
callq 0x44a0
movq 0x4752(%rip), %rdx      # 0xaf38
movq %rax, %rsi
subq (%rdx), %rsi
movq 0x47bd(%rip), %rcx      # 0xafb0
movq (%rcx), %rdi
addq %rsi, 0x90(%rdi)
movq %rax, (%rdx)
movq 0x46c1(%rip), %rdx      # 0xaec8
movq 0x4702(%rip), %rax      # 0xaf10
imulq $0x28, (%rdx), %rsi
cmpq $0x0, (%rax,%rsi)
movq (%rdx), %rsi
jne 0x6824
decq %rsi
movq %rsi, (%rdx)
jmp 0x680e
imulq $0x28, %rsi, %rsi
leaq (%rax,%rsi), %rdi
addq $0x10, %rdi
movq -0x8(%rdi), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0x8(%rdi)
cmpq %rdi, %rdx
jne 0x684c
addq %rsi, %rax
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rax)
movq 0x18(%rdx), %rax
movq %rax, (%rcx)
movq 0x46fe(%rip), %rdx      # 0xaf58
cmpq $0x0, (%rdx)
je 0x67d8
movq 0x46bd(%rip), %rax      # 0xaf28
movq (%rax), %rsi
movq (%rcx), %rdi
cmpq 0x78(%rdi), %rsi
je 0x67d8
movq 0x467e(%rip), %rsi      # 0xaf00
movq (%rsi), %rdi
addq $0x10, %rdi
movq 0x4668(%rip), %r8       # 0xaef8
cmpq (%r8), %rdi
jae 0x68c4
movq (%rcx), %rcx
movq 0x78(%rcx), %rcx
movq %rcx, (%rax)
movq 0x463a(%rip), %rcx      # 0xaee0
movl (%rcx), %ecx
movq (%rsi), %rdx
movq %rcx, (%rdx)
addq $0x8, (%rsi)
movq (%rax), %rax
movq (%rsi), %rcx
movq %rax, (%rcx)
addq $0x8, (%rsi)
jmp 0x67d8
andq $0x0, (%rdx)
jmp 0x67d8
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: xTaskCheckForTimeOut
portBASE_TYPE xTaskCheckForTimeOut( xTimeOutType * const pxTimeOut, portTickType * const pxTicksToWait )
{
portBASE_TYPE xReturn;

	portENTER_CRITICAL();
	{
		#if ( INCLUDE_vTaskSuspend == 1 )
			/* If INCLUDE_vTaskSuspend is set to 1 and the block time specified is
			the maximum block time then the task should block indefinitely, and
			therefore never time out. */
			if( *pxTicksToWait == portMAX_DELAY )
			{
				xReturn = pdFALSE;
			}
			else /* We are not blocking indefinitely, perform the checks below. */
		#endif

		if( ( xNumOfOverflows != pxTimeOut->xOverflowCount ) && ( ( portTickType ) xTickCount >= ( portTickType ) pxTimeOut->xTimeOnEntering ) )
		{
			/* The tick count is greater than the time at which vTaskSetTimeout()
			was called, but has also overflowed since vTaskSetTimeOut() was called.
			It must have wrapped all the way around and gone past us again. This
			passed since vTaskSetTimeout() was called. */
			xReturn = pdTRUE;
		}
		else if( ( ( portTickType ) ( ( portTickType ) xTickCount - ( portTickType ) pxTimeOut->xTimeOnEntering ) ) < ( portTickType ) *pxTicksToWait )
		{
			/* Not a genuine timeout. Adjust parameters for time remaining. */
			*pxTicksToWait -= ( ( portTickType ) xTickCount - ( portTickType ) pxTimeOut->xTimeOnEntering );
			vTaskSetTimeOutState( pxTimeOut );
			xReturn = pdFALSE;
		}
		else
		{
			xReturn = pdTRUE;
		}
	}
	portEXIT_CRITICAL();

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4340
movl (%r14), %eax
cmpl $-0x1, %eax
je 0x6a56
movq 0x45d4(%rip), %rcx      # 0xafe8
movq (%rcx), %rdx
pushq $0x1
popq %r15
cmpq (%rbx), %rdx
jne 0x6a25
movl 0x8(%rbx), %edx
jmp 0x6a35
movq 0x44b4(%rip), %rdx      # 0xaee0
movl (%rdx), %esi
movl 0x8(%rbx), %edx
cmpl %edx, %esi
jae 0x6a59
movq 0x44a4(%rip), %rsi      # 0xaee0
movl (%rsi), %edi
subl %edx, %edi
cmpl %eax, %edi
jae 0x6a59
addl %eax, %edx
subl (%rsi), %edx
movl %edx, (%r14)
movq (%rcx), %rax
movq %rax, (%rbx)
movl (%rsi), %eax
movl %eax, 0x8(%rbx)
xorl %r15d, %r15d
callq 0x44b0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: prvCheckTasksWaitingTermination
static void prvCheckTasksWaitingTermination( void )
{
	#if ( INCLUDE_vTaskDelete == 1 )
	{
		portBASE_TYPE xListIsEmpty;

		/* ucTasksDeleted is used to prevent vTaskSuspendAll() being called
		too often in the idle task. */
		if( uxTasksDeleted > ( unsigned portBASE_TYPE ) 0 )
		{
			vTaskSuspendAll();
				xListIsEmpty = listLIST_IS_EMPTY( &xTasksWaitingTermination );
			xTaskResumeAll();

			if( !xListIsEmpty )
			{
				tskTCB *pxTCB;

				portENTER_CRITICAL();
				{
					pxTCB = ( tskTCB * ) listGET_OWNER_OF_HEAD_ENTRY( ( ( xList * ) &xTasksWaitingTermination ) );
					vListRemove( &( pxTCB->xGenericListItem ) );
					--uxCurrentNumberOfTasks;
					--uxTasksDeleted;
				}
				portEXIT_CRITICAL();

				prvDeleteTCB( pxTCB );
			}
		}
	}
	#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x43ff(%rip), %r14      # 0xae90
cmpq $0x0, (%r14)
je 0x6af2
movq 0x44ca(%rip), %rax      # 0xaf68
incq (%rax)
movq 0x44e0(%rip), %rbx      # 0xaf88
movq (%rbx), %r15
callq 0x4080
testq %r15, %r15
je 0x6af2
callq 0x4340
movq (%rbx), %rax
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rbx
leaq 0x8(%rbx), %rdi
callq 0x4040
movq 0x446b(%rip), %rax      # 0xaf40
decq (%rax)
decq (%r14)
callq 0x44b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4110
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq