LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x58ba
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x58b5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x43c0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x598f
cmpq $0x0, -0x18(%rbp)
jne 0x591b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movl %eax, %eax
movl %eax, %edx
callq 0x4360
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x5919
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x598d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movl %eax, %eax
movl %eax, %edx
callq 0x4360
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x598b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
subq 0x80(%rdx), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x598d
jmp 0x598f
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%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/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4330
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x10(%rbp)
callq 0x44a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5c12
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x5bf2
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movl %eax, %eax
movl %eax, %edx
callq 0x4360
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: prvIsQueueEmpty
static signed portBASE_TYPE prvIsQueueEmpty( const xQueueHandle pxQueue )
{
signed portBASE_TYPE xReturn;

	taskENTER_CRITICAL();
		xReturn = ( pxQueue->uxMessagesWaiting == ( unsigned portBASE_TYPE ) 0 );
	taskEXIT_CRITICAL();

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4330
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x10(%rbp)
callq 0x44a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/queue.c
// Function: xQueueReceiveFromISR
signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue, void * const pvBuffer, signed portBASE_TYPE *pxTaskWoken )
{
signed portBASE_TYPE xReturn;
unsigned portBASE_TYPE uxSavedInterruptStatus;

	uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
	{
		/* We cannot block from an ISR, so check there is data available. */
		if( pxQueue->uxMessagesWaiting > ( unsigned portBASE_TYPE ) 0 )
		{
			traceQUEUE_RECEIVE_FROM_ISR( pxQueue );

			prvCopyDataFromQueue( pxQueue, pvBuffer );
			--( pxQueue->uxMessagesWaiting );

			/* If the queue is locked we will not modify the event list.  Instead
			we update the lock count so the task that unlocks the queue will know
			that an ISR has removed data while the queue was locked. */
			if( pxQueue->xRxLock == queueUNLOCKED )
			{
				if( !listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) )
				{
					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )
					{
						/* The task waiting has a higher priority than us so
						force a context switch. */
						*pxTaskWoken = pdTRUE;
					}
				}
			}
			else
			{
				/* Increment the lock count so the task that unlocks the queue
				knows that data was removed while it was locked. */
				++( pxQueue->xRxLock );
			}

			xReturn = pdPASS;
		}
		else
		{
			xReturn = pdFAIL;
			traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue );
		}
	}
	portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x41c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
cmpq $0x0, %rax
jbe 0x5d06
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5ba0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
cmpq $-0x1, 0x88(%rax)
jne 0x5ce6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, %rax
je 0x5ce4
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x4220
cmpq $0x0, %rax
je 0x5ce2
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
jmp 0x5ce4
jmp 0x5cfc
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x88(%rax)
movq $0x1, -0x20(%rbp)
jmp 0x5d0e
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4730
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4330
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x44a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x609f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5870
cmpq $0x0, -0x20(%rbp)
jne 0x609d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, %rax
je 0x609b
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x46a0
cmpq $0x0, %rax
je 0x6099
movq $0x1, -0x8(%rbp)
jmp 0x60a7
jmp 0x609b
jmp 0x609d
jmp 0x609f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
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/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
cmpq $0x0, %rax
jbe 0x6192
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x611e
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movl %eax, %eax
movl %eax, %edx
callq 0x4360
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6188
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, %rax
je 0x6186
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x46a0
cmpq $0x0, %rax
je 0x6184
movq -0x18(%rbp), %rax
movq $0x1, (%rax)
jmp 0x6186
jmp 0x6188
movq $0x1, -0x20(%rbp)
jmp 0x619a
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x98, %edi
callq 0x42f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6474
cmpq $0x0, -0x10(%rbp)
jne 0x6424
movzwl -0x2(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x42f0
movq %rax, -0x20(%rbp)
jmp 0x642c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x6456
movq -0x18(%rbp), %rdi
callq 0x41a0
movq $0x0, -0x18(%rbp)
jmp 0x6472
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
movzwl -0x2(%rbp), %eax
movl %eax, %edx
shlq $0x3, %rdx
movl $0xa5, %esi
callq 0x41f0
jmp 0x6474
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0xa, -0x8(%rbp)
jae 0x6599
movq 0x7992(%rip), %rdi      # 0xdf10
imulq $0x28, -0x8(%rbp), %rax
addq %rax, %rdi
callq 0x43b0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x6570
movq 0x79a8(%rip), %rdi      # 0xdf48
callq 0x43b0
movq 0x78fc(%rip), %rdi      # 0xdea8
callq 0x43b0
movq 0x79e0(%rip), %rdi      # 0xdf98
callq 0x43b0
movq 0x79c4(%rip), %rdi      # 0xdf88
callq 0x43b0
movq 0x7938(%rip), %rdi      # 0xdf08
callq 0x43b0
movq 0x79e4(%rip), %rax      # 0xdfc0
movq 0x7965(%rip), %rcx      # 0xdf48
movq %rcx, (%rax)
movq 0x7973(%rip), %rax      # 0xdf60
movq 0x78b4(%rip), %rcx      # 0xdea8
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4330
movq -0x8(%rbp), %rax
movq 0x7994(%rip), %rcx      # 0xdfb0
movq (%rcx), %rcx
cmpq %rcx, %rax
jne 0x662c
movq $0x0, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6643
movq 0x7976(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x664b
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x6678
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x4040
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq 0x7901(%rip), %rdi      # 0xdf88
callq 0x4760
movq 0x77fd(%rip), %rax      # 0xde90
movq (%rax), %rcx
addq $0x1, %rcx
movq 0x77ef(%rip), %rax      # 0xde90
movq %rcx, (%rax)
movq 0x7885(%rip), %rax      # 0xdf30
movq (%rax), %rcx
addq $0x1, %rcx
movq 0x7877(%rip), %rax      # 0xdf30
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x45d0
callq 0x44a0
movq 0x787f(%rip), %rax      # 0xdf50
movq (%rax), %rax
cmpq $0x0, %rax
je 0x66e8
cmpq $0x0, -0x8(%rbp)
jne 0x66e6
callq 0x4560
jmp 0x66e8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4330
cmpq $0x0, -0x8(%rbp)
jne 0x6ad8
movq 0x74e1(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6ae0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x44a0
movq -0x18(%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/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4330
movq -0x8(%rbp), %rax
movq 0x72f4(%rip), %rcx      # 0xdfb0
movq (%rcx), %rcx
cmpq %rcx, %rax
jne 0x6ccc
movq $0x0, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6ce3
movq 0x72d6(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6ceb
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x6d18
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x4040
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq 0x71e1(%rip), %rdi      # 0xdf08
callq 0x4760
callq 0x44a0
cmpq $0x0, -0x8(%rbp)
jne 0x6d3d
callq 0x4560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: xTaskIsTaskSuspended
signed portBASE_TYPE xTaskIsTaskSuspended( xTaskHandle xTask )
	{
	portBASE_TYPE xReturn = pdFALSE;
	const tskTCB * const pxTCB = ( tskTCB * ) xTask;

		/* Is the task we are attempting to resume actually in the
		suspended list? */
		if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) ) != pdFALSE )
		{
			/* Has the task already been resumed from within an ISR? */
			if( listIS_CONTAINED_WITHIN( &xPendingReadyList, &( pxTCB->xEventListItem ) ) != pdTRUE )
			{
				/* Is it in the suspended list because it is in the
				Suspended state?  It is possible to be in the suspended
				list because it is blocked on a task with no timeout
				specified. */
				if( listIS_CONTAINED_WITHIN( NULL, &( pxTCB->xEventListItem ) ) == pdTRUE )
				{
					xReturn = pdTRUE;
				}
			}
		}

		return xReturn;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x7195(%rip), %rcx      # 0xdf08
cmpq %rcx, 0x28(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x6dc2
movq -0x18(%rbp), %rax
movq 0x7209(%rip), %rcx      # 0xdf98
cmpq %rcx, 0x50(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x6dc0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6dbe
movq $0x1, -0x10(%rbp)
jmp 0x6dc0
jmp 0x6dc2
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6e94
movq -0x10(%rbp), %rax
movq 0x71b6(%rip), %rcx      # 0xdfb0
movq (%rcx), %rcx
cmpq %rcx, %rax
je 0x6e94
callq 0x4330
movq -0x10(%rbp), %rdi
callq 0x4590
cmpq $0x1, %rax
jne 0x6e8f
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x7092(%rip), %rcx      # 0xdec8
movq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x6e50
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq 0x707b(%rip), %rax      # 0xdec8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x70b5(%rip), %rdi      # 0xdf10
imulq $0x28, 0x58(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x4760
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x7131(%rip), %rcx      # 0xdfb0
movq (%rcx), %rcx
cmpq 0x58(%rcx), %rax
jb 0x6e8d
callq 0x4560
jmp 0x6e8f
callq 0x44a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4590
cmpq $0x1, %rax
jne 0x6f71
movq 0x7092(%rip), %rax      # 0xdf68
movq (%rax), %rax
cmpq $0x0, %rax
jne 0x6f5b
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x70c2(%rip), %rcx      # 0xdfb0
movq (%rcx), %rcx
cmpq 0x58(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x6fa9(%rip), %rcx      # 0xdec8
movq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x6f39
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
movq 0x6f92(%rip), %rax      # 0xdec8
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x6fcc(%rip), %rdi      # 0xdf10
imulq $0x28, 0x58(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x4760
jmp 0x6f6f
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
movq 0x702e(%rip), %rdi      # 0xdf98
callq 0x4760
jmp 0x6f71
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
callq 0x4330
movq 0x6cec(%rip), %rax      # 0xdee0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
callq 0x44a0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x73aa
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x73ff
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x47a0
movw %ax, -0x2a(%rbp)
movq -0x20(%rbp), %rdx
addq $0x68, %rdx
movsbl -0x11(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %r8d
movzwl -0x2a(%rbp), %r9d
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rax
movq 0x6ba5(%rip), %rdi      # 0xdff0
leaq 0x3bb3(%rip), %rsi      # 0xb005
movl %eax, (%rsp)
movb $0x0, %al
callq 0x46b0
movq -0x8(%rbp), %rdi
movq 0x6b89(%rip), %rsi      # 0xdff0
callq 0x4680
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x73ba
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4330
movq -0x8(%rbp), %rcx
movq 0x6770(%rip), %rax      # 0xdf00
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq 0x683a(%rip), %rax      # 0xdfd8
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
subq $0x10, %rax
addq %rax, %rcx
movq 0x6741(%rip), %rax      # 0xdef8
movq %rcx, (%rax)
movq 0x6797(%rip), %rax      # 0xdf58
movq $0x1, (%rax)
callq 0x44a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
callq 0x4330
movq 0x6764(%rip), %rax      # 0xdf58
movq $0x0, (%rax)
callq 0x44a0
movq 0x66f9(%rip), %rax      # 0xdf00
movq (%rax), %rax
movq 0x67c7(%rip), %rcx      # 0xdfd8
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskSetApplicationTaskTag
void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxTagValue )
	{
	tskTCB *xTCB;

		/* If xTask is NULL then we are setting our own task hook. */
		if( xTask == NULL )
		{
			xTCB = ( tskTCB * ) pxCurrentTCB;
		}
		else
		{
			xTCB = ( tskTCB * ) xTask;
		}

		/* Save the hook function in the TCB.  A critical section is required as
		the value can be accessed from an interrupt. */
		portENTER_CRITICAL();
			xTCB->pxTaskTag = pxTagValue;
		portEXIT_CRITICAL();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7b57
movq 0x6462(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7b5f
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x4330
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x88(%rax)
callq 0x44a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: xTaskGetApplicationTaskTag
pdTASK_HOOK_CODE xTaskGetApplicationTaskTag( xTaskHandle xTask )
	{
	tskTCB *xTCB;
	pdTASK_HOOK_CODE xReturn;

		/* If xTask is NULL then we are setting our own task hook. */
		if( xTask == NULL )
		{
			xTCB = ( tskTCB * ) pxCurrentTCB;
		}
		else
		{
			xTCB = ( tskTCB * ) xTask;
		}

		/* Save the hook function in the TCB.  A critical section is required as
		the value can be accessed from an interrupt. */
		portENTER_CRITICAL();
			xReturn = xTCB->pxTaskTag;
		portEXIT_CRITICAL();

		return xReturn;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7ba3
movq 0x6416(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7bab
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x4330
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x44a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: xTaskCallApplicationTaskHook
portBASE_TYPE xTaskCallApplicationTaskHook( xTaskHandle xTask, void *pvParameter )
	{
	tskTCB *xTCB;
	portBASE_TYPE xReturn;

		/* If xTask is NULL then we are calling our own task hook. */
		if( xTask == NULL )
		{
			xTCB = ( tskTCB * ) pxCurrentTCB;
		}
		else
		{
			xTCB = ( tskTCB * ) xTask;
		}

		if( xTCB->pxTaskTag != NULL )
		{
			xReturn = xTCB->pxTaskTag( pvParameter );
		}
		else
		{
			xReturn = pdFAIL;
		}

		return xReturn;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7bf7
movq 0x63c2(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7bff
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x7c24
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
jmp 0x7c2c
movq $0x0, -0x20(%rbp)
movq -0x20(%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/tasks.c
// Function: xTaskRemoveFromEventList
signed portBASE_TYPE xTaskRemoveFromEventList( const xList * const pxEventList )
{
tskTCB *pxUnblockedTCB;
portBASE_TYPE xReturn;

	/* THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED OR THE
	SCHEDULER SUSPENDED.  It can also be called from within an ISR. */

	/* The event list is sorted in priority order, so we can remove the
	first in the list, remove the TCB from the delayed list, and add
	it to the ready list.

	If an event is for a queue that is locked then this function will never
	get called - the lock count on the queue will get modified instead.  This
	means we can always expect exclusive access to the event list here. */
	pxUnblockedTCB = ( tskTCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );
	vListRemove( &( pxUnblockedTCB->xEventListItem ) );

	if( uxSchedulerSuspended == ( unsigned portBASE_TYPE ) pdFALSE )
	{
		vListRemove( &( pxUnblockedTCB->xGenericListItem ) );
		prvAddTaskToReadyQueue( pxUnblockedTCB );
	}
	else
	{
		/* We cannot access the delayed or ready lists, so will hold this
		task pending until the scheduler is resumed. */
		vListInsertEnd( ( xList * ) &( xPendingReadyList ), &( pxUnblockedTCB->xEventListItem ) );
	}

	if( pxUnblockedTCB->uxPriority >= pxCurrentTCB->uxPriority )
	{
		/* Return true if the task removed from the event list has
		a higher priority than the calling task.  This allows
		the calling task to know if it should force a context
		switch now. */
		xReturn = pdTRUE;
	}
	else
	{
		xReturn = pdFALSE;
	}

	return xReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, %rax
je 0x7f2b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7f33
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x7f33
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x4040
movq 0x6019(%rip), %rax      # 0xdf68
movq (%rax), %rax
cmpq $0x0, %rax
jne 0x7fb0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x5f54(%rip), %rcx      # 0xdec8
movq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x7f8e
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq 0x5f3d(%rip), %rax      # 0xdec8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x5f77(%rip), %rdi      # 0xdf10
imulq $0x28, 0x58(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x4760
jmp 0x7fc4
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq 0x5fd9(%rip), %rdi      # 0xdf98
callq 0x4760
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x5fdd(%rip), %rcx      # 0xdfb0
movq (%rcx), %rcx
cmpq 0x58(%rcx), %rax
jb 0x7fe6
movq $0x1, -0x18(%rbp)
jmp 0x7fee
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4330
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x805b
movq $0x0, -0x18(%rbp)
jmp 0x80db
movq 0x5f86(%rip), %rax      # 0xdfe8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x808a
movq 0x5e6b(%rip), %rax      # 0xdee0
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x808a
movq $0x1, -0x18(%rbp)
jmp 0x80d9
movq 0x5e4f(%rip), %rax      # 0xdee0
movl (%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x80cf
movq 0x5e37(%rip), %rax      # 0xdee0
movl (%rax), %edx
movq -0x8(%rbp), %rax
subl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x4670
movq $0x0, -0x18(%rbp)
jmp 0x80d7
movq $0x1, -0x18(%rbp)
jmp 0x80d9
jmp 0x80db
callq 0x44a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq 0x5d71(%rip), %rax      # 0xde90
movq (%rax), %rax
cmpq $0x0, %rax
jbe 0x81e4
callq 0x4650
movq 0x5e50(%rip), %rax      # 0xdf88
movq (%rax), %rax
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x8(%rbp)
callq 0x4080
cmpq $0x0, -0x8(%rbp)
jne 0x81e2
callq 0x4330
movq 0x5e1f(%rip), %rax      # 0xdf88
movq (%rax), %rax
cmpq $0x0, %rax
je 0x8187
movq 0x5e0f(%rip), %rax      # 0xdf88
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x818f
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x818f
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq 0x5d95(%rip), %rax      # 0xdf40
movq (%rax), %rcx
addq $-0x1, %rcx
movq 0x5d87(%rip), %rax      # 0xdf40
movq %rcx, (%rax)
movq 0x5ccd(%rip), %rax      # 0xde90
movq (%rax), %rcx
addq $-0x1, %rcx
movq 0x5cbf(%rip), %rax      # 0xde90
movq %rcx, (%rax)
callq 0x44a0
movq -0x10(%rbp), %rdi
callq 0x4100
jmp 0x81e4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: usTaskCheckFreeStackSpace
static unsigned short usTaskCheckFreeStackSpace( const unsigned char * pucStackByte )
	{
	register unsigned short usCount = 0;

		while( *pucStackByte == tskSTACK_FILL_BYTE )
		{
			pucStackByte -= portSTACK_GROWTH;
			usCount++;
		}

		usCount /= sizeof( portSTACK_TYPE );

		return usCount;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movw $0x0, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa5, %eax
jne 0x8226
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x81fe
movzwl -0xa(%rbp), %eax
shrq $0x3, %rax
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskPriorityInherit
void vTaskPriorityInherit( xTaskHandle * const pxMutexHolder )
	{
	tskTCB * const pxTCB = ( tskTCB * ) pxMutexHolder;

		if( pxTCB->uxPriority < pxCurrentTCB->uxPriority )
		{
			/* Adjust the mutex holder state to account for its new priority. */
			listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) pxCurrentTCB->uxPriority );

			/* If the task being modified is in the ready state it will need to
			be moved in to a new list. */
			if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) ) )
			{
				vListRemove( &( pxTCB->xGenericListItem ) );

				/* Inherit the priority before being moved into the new list. */
				pxTCB->uxPriority = pxCurrentTCB->uxPriority;
				prvAddTaskToReadyQueue( pxTCB );
			}
			else
			{
				/* Just inherit the priority. */
				pxTCB->uxPriority = pxCurrentTCB->uxPriority;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x5cdd(%rip), %rcx      # 0xdfb0
movq (%rcx), %rcx
cmpq 0x58(%rcx), %rax
jae 0x83a9
movq 0x5cc9(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq 0x58(%rax), %rax
movl %eax, %eax
movl %eax, %ecx
movl $0xa, %eax
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x5bfa(%rip), %rcx      # 0xdf10
imulq $0x28, 0x58(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x8391
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq 0x5c79(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq 0x58(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x5b73(%rip), %rcx      # 0xdec8
movq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x836f
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq 0x5b5c(%rip), %rax      # 0xdec8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x5b96(%rip), %rdi      # 0xdf10
imulq $0x28, 0x58(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x4760
jmp 0x83a7
movq 0x5c18(%rip), %rax      # 0xdfb0
movq (%rax), %rax
movq 0x58(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x83a9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/weaslepalace[P]FreeRTOS_Posix_Sim/FreeRTOS_Kernel/tasks.c
// Function: vTaskPriorityDisinherit
void vTaskPriorityDisinherit( xTaskHandle * const pxMutexHolder )
	{
	tskTCB * const pxTCB = ( tskTCB * ) pxMutexHolder;

		if( pxMutexHolder != NULL )
		{
			if( pxTCB->uxPriority != pxTCB->uxBasePriority )
			{
				/* We must be the running task to be able to give the mutex back.
				Remove ourselves from the ready list we currently appear in. */
				vListRemove( &( pxTCB->xGenericListItem ) );

				/* Disinherit the priority before adding ourselves into the new
				ready list. */
				pxTCB->uxPriority = pxTCB->uxBasePriority;
				listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) pxTCB->uxPriority );
				prvAddTaskToReadyQueue( pxTCB );
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8470
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x80(%rcx), %rax
je 0x846e
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x4040
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %eax
movl %eax, %ecx
movl $0xa, %eax
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x5a94(%rip), %rcx      # 0xdec8
movq (%rcx), %rcx
cmpq %rcx, %rax
jbe 0x844e
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq 0x5a7d(%rip), %rax      # 0xdec8
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x5ab7(%rip), %rdi      # 0xdf10
imulq $0x28, 0x58(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x4760
jmp 0x8470
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)