cli
	push r16
	ld r16,y+
	.dbline 877
	.dbline 878
;     if ((OSIntNesting == 0) && (OSLockNesting == 0)) { /* Sched. only if all ISRs done & not locked    */
	lds R2,_OSIntNesting
	tst R2
	breq X10
	xjmp L55
X10:
	lds R2,_OSLockNesting
	tst R2
	breq X11
	xjmp L55
X11:
	.dbline 878
	.dbline 879
;         y             = OSUnMapTbl[OSRdyGrp];          /* Get pointer to HPT ready to run              */
	ldi R24,<_OSUnMapTbl
	ldi R25,>_OSUnMapTbl
	lds R30,_OSRdyGrp
	clr R31
	add R30,R24
	adc R31,R25
	lpm R10,Z
	.dbline 880
;         OSPrioHighRdy = (INT8U)((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);
	ldi R24,<_OSRdyTbl
	ldi R25,>_OSRdyTbl
	mov R30,R10
	clr R31
	add R30,R24
	adc R31,R25
	ldd R30,z+0
	clr R31
	ldi R24,<_OSUnMapTbl
	ldi R25,>_OSUnMapTbl
	add R30,R24
	adc R31,R25
	lpm R2,Z
	clr R3
	mov R4,R10
	clr R5
	lsl R4
	rol R5
	lsl R4
	rol R5
	lsl R4
	rol R5
	add R4,R2
	adc R5,R3
	sts _OSPrioHighRdy,R4
	.dbline 881
;         if (OSPrioHighRdy != OSPrioCur) {              /* No Ctx Sw if current task is highest rdy     */
	lds R2,_OSPrioCur
	cp R4,R2
	breq L57
	.dbline 881
	.dbline 882
;             OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
	mov R2,R4
	ldi R24,2
	mul R24,R2
	movw R30,R0
	ldi R24,<_OSTCBPrioTbl
	ldi R25,>_OSTCBPrioTbl
	add R30,R24
	adc R31,R25
	ldd R2,z+0
	ldd R3,z+1
	sts _OSTCBHighRdy+1,R3
	sts _OSTCBHighRdy,R2
	.dbline 884
; 
;             OSCtxSwCtr++;                              /* Increment context switch counter             */
	ldi R20,1
	ldi R21,0
	ldi R22,0
	ldi R23,0
	lds R4,_OSCtxSwCtr+2
	lds R5,_OSCtxSwCtr+2+1
	lds R2,_OSCtxSwCtr
	lds R3,_OSCtxSwCtr+1
	add R2,R20
	adc R3,R21
	adc R4,R22
	adc R5,R23
	sts _OSCtxSwCtr+1,R3
	sts _OSCtxSwCtr,R2
	sts _OSCtxSwCtr+2+1,R5
	sts _OSCtxSwCtr+2,R4
	.dbline 885
;             OS_TASK_SW();                              /* Perform a context switch                     */
	xcall _OSCtxSw
	.dbline 886
;         }
L57:
	.dbline 887
;     }
L55:
	.dbline 888
;     OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 888
	.dbline -2
L54:
	xcall pop_gset3
	.dbline 0 ; func end
	ret
	.dbsym r y 10 c
	.dbend
	.dbfunc e OS_TaskIdle _OS_TaskIdle fV
;          pdata -> R10,R11
	.even
_OS_TaskIdle::
	xcall push_gset3
	movw R10,R16
	.dbline -1
	.dbline 913
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                              IDLE TASK
; *
; * Description: This task is internal to uC/OS-II and executes whenever no other higher priority tasks
; *              executes because they are ALL waiting for event(s) to occur.
; *
; * Arguments  : none
; *
; * Returns    : none
; *
; * Note(s)    : 1) OSTaskIdleHook() is called after the critical section to ensure that interrupts will be
; *                 enabled for at least a few instructions.  On some processors (ex. Philips XA), enabling
; *                 and then disabling interrupts didn't allow the processor enough time to have interrupts
; *                 enabled before they were disabled again.  uC/OS-II would thus never recognize
; *                 interrupts.
; *              2) This hook has been added to allow you to do such things as STOP the CPU to conserve 
; *                 power.
; *********************************************************************************************************
; */
; 
; void  OS_TaskIdle (void *pdata)
; {
	.dbline 919
; #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
;     OS_CPU_SR  cpu_sr;
; #endif    
;     
;     
;     pdata = pdata;                               /* Prevent compiler warning for not using 'pdata'     */
	.dbline 920
L60:
	.dbline 920
	.dbline 921
	st -y,r16
	in r16,0x3F
	cli
	push r16
	ld r16,y+
	.dbline 921
	.dbline 922
	ldi R20,1
	ldi R21,0
	ldi R22,0
	ldi R23,0
	lds R4,_OSIdleCtr+2
	lds R5,_OSIdleCtr+2+1
	lds R2,_OSIdleCtr
	lds R3,_OSIdleCtr+1
	add R2,R20
	adc R3,R21
	adc R4,R22
	adc R5,R23
	sts _OSIdleCtr+1,R3
	sts _OSIdleCtr,R2
	sts _OSIdleCtr+2+1,R5
	sts _OSIdleCtr+2,R4
	.dbline 923
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 923
	.dbline 925
	xcall _OSTaskIdleHook
	.dbline 926
	.dbline 920
	.dbline 920
	xjmp L60
X12:
	.dbline -2
L59:
	xcall pop_gset3
	.dbline 0 ; func end
	ret
	.dbsym r pdata 10 pV
	.dbend
	.dbfunc e OS_TCBInit _OS_TCBInit fc
;           ptcb -> R20,R21
;            opt -> y+16
;           pext -> y+14
;       stk_size -> y+10
;             id -> y+8
;           pbos -> y+6
;           ptos -> R10,R11
;           prio -> R22
	.even
_OS_TCBInit::
	xcall push_gset3
	movw R10,R18
	mov R22,R16
	.dbline -1
	.dbline 1038
;     for (;;) {
;         OS_ENTER_CRITICAL();
;         OSIdleCtr++;
;         OS_EXIT_CRITICAL();
; //		OSTimeDly (5);
;         OSTaskIdleHook();                        /* Call user definable HOOK                           */
;     }
; }
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                            STATISTICS TASK
; *
; * Description: This task is internal to uC/OS-II and is used to compute some statistics about the
; *              multitasking environment.  Specifically, OS_TaskStat() computes the CPU usage.
; *              CPU usage is determined by:
; *
; *                                          OSIdleCtr
; *                 OSCPUUsage = 100 * (1 - ------------)     (units are in %)
; *                                         OSIdleCtrMax
; *
; * Arguments  : pdata     this pointer is not used at this time.
; *
; * Returns    : none
; *
; * Notes      : 1) This task runs at a priority level higher than the idle task.  In fact, it runs at the
; *                 next higher priority, OS_IDLE_PRIO-1.
; *              2) You can disable this task by setting the configuration #define OS_TASK_STAT_EN to 0.
; *              3) We delay for 5 seconds in the beginning to allow the system to reach steady state and
; *                 have all other tasks created before we do statistics.  You MUST have at least a delay
; *                 of 2 seconds to allow for the system to establish the maximum value for the idle
; *                 counter.
; *********************************************************************************************************
; */
; 
; #if OS_TASK_STAT_EN > 0
; void  OS_TaskStat (void *pdata)
; {
; #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
;     OS_CPU_SR  cpu_sr;
; #endif    
;     INT32U     run;
;     INT32U     max;
;     INT8S      usage;
; 
; 
;     pdata = pdata;                               /* Prevent compiler warning for not using 'pdata'     */
;     while (OSStatRdy == FALSE) {
;         OSTimeDly(2 * OS_TICKS_PER_SEC);         /* Wait until statistic task is ready                 */
;     }
;     max = OSIdleCtrMax / 100L;
;     for (;;) {
;         OS_ENTER_CRITICAL();
;         OSIdleCtrRun = OSIdleCtr;                /* Obtain the of the idle counter for the past second */
;         run          = OSIdleCtr;
;         OSIdleCtr    = 0L;                       /* Reset the idle counter for the next second         */
;         OS_EXIT_CRITICAL();
;         if (max > 0L) {
;             usage = (INT8S)(100L - run / max);
;             if (usage >= 0) {                    /* Make sure we don't have a negative percentage      */
;                 OSCPUUsage = usage;
;             } else {
;                 OSCPUUsage = 0;
;             }
;         } else {
;             OSCPUUsage = 0;
;             max        = OSIdleCtrMax / 100L;
;         }
;         OSTaskStatHook();                        /* Invoke user definable hook                         */
;         OSTimeDly(OS_TICKS_PER_SEC);             /* Accumulate OSIdleCtr for the next second           */
;     }
; }
; #endif
; /*$PAGE*/
; /*
; *********************************************************************************************************
; *                                            INITIALIZE TCB
; *
; * Description: This function is internal to uC/OS-II and is used to initialize a Task Control Block when
; *              a task is created (see OSTaskCreate() and OSTaskCreateExt()).
; *
; * Arguments  : prio          is the priority of the task being created
; *
; *              ptos          is a pointer to the task's top-of-stack assuming that the CPU registers
; *                            have been placed on the stack.  Note that the top-of-stack corresponds to a
; *                            'high' memory location is OS_STK_GROWTH is set to 1 and a 'low' memory
; *                            location if OS_STK_GROWTH is set to 0.  Note that stack growth is CPU
; *                            specific.
; *
; *              pbos          is a pointer to the bottom of stack.  A NULL pointer is passed if called by
; *                            'OSTaskCreate()'.
; *
; *              id            is the task's ID (0..65535)
; *
; *              stk_size      is the size of the stack (in 'stack units').  If the stack units are INT8Us
; *                            then, 'stk_size' contains the number of bytes for the stack.  If the stack
; *                            units are INT32Us then, the stack contains '4 * stk_size' bytes.  The stack
; *                            units are established by the #define constant OS_STK which is CPU
; *                            specific.  'stk_size' is 0 if called by 'OSTaskCreate()'.
; *
; *              pext          is a pointer to a user supplied memory area that is used to extend the task
; *                            control block.  This allows you to store the contents of floating-point
; *                            registers, MMU registers or anything else you could find useful during a
; *                            context switch.  You can even assign a name to each task and store this name
; *                            in this TCB extension.  A NULL pointer is passed if called by OSTaskCreate().
; *
; *              opt           options as passed to 'OSTaskCreateExt()' or,
; *                            0 if called from 'OSTaskCreate()'.
; *
; * Returns    : OS_NO_ERR         if the call was successful
; *              OS_NO_MORE_TCB    if there are no more free TCBs to be allocated and thus, the task cannot
; *                                be created.
; *
; * Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
; *********************************************************************************************************
; */
; 
; INT8U  OS_TCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt)
; {
	.dbline 1045
; #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
;     OS_CPU_SR  cpu_sr;
; #endif    
;     OS_TCB    *ptcb;
; 
; 
;     OS_ENTER_CRITICAL();
	st -y,r16
	in r16,0x3F
	cli
	push r16
	ld r16,y+
	.dbline 1045
	.dbline 1046
;     ptcb = OSTCBFreeList;                                  /* Get a free TCB from the free TCB list    */
	lds R20,_OSTCBFreeList
	lds R21,_OSTCBFreeList+1
	.dbline 1047
;     if (ptcb != (OS_TCB *)0) {
	cpi R20,0
	cpc R20,R21
	brne X15
	xjmp L65
X15:
X13:
	.dbline 1047
	.dbline 1048
;         OSTCBFreeList        = ptcb->OSTCBNext;            /* Update pointer to free TCB list          */
	movw R30,R20
	ldd R2,z+2
	ldd R3,z+3
	sts _OSTCBFreeList+1,R3
	sts _OSTCBFreeList,R2
	.dbline 1049
;         OS_EXIT_CRITICAL();
	st -y,r16
	pop r16
	out 0x3F,r16
	ld r16,y+
	.dbline 1049
	.dbline 1050
;         ptcb->OSTCBStkPtr    = ptos;                       /* Load Stack pointer in TCB                */
	movw R30,R20
	std z+1,R11
	std z+0,R10
	.dbline 1051
;         ptcb->OSTCBPrio      = (INT8U)prio;                /* Load task priority into TCB              */
	std z+12,R22
	.dbline 1052
;         ptcb->OSTCBStat      = OS_STAT_RDY;                /* Task is ready to run                     */
	clr R2
	movw R30,R20
	std z+11,R2
	.dbline 1053
;         ptcb->OSTCBDly       = 0;                          /* Task is not delayed                      */
	clr R3
	movw R30,R20
	std z+10,R3
	std z+9,R2
	.dbline 1062
; 
; #if OS_TASK_CREATE_EXT_EN > 0
;         ptcb->OSTCBExtPtr    = pext;                       /* Store pointer to TCB extension           */
;         ptcb->OSTCBStkSize   = stk_size;                   /* Store stack size                         */
;         ptcb->OSTCBStkBottom = pbos;                       /* Store pointer to bottom of stack         */
;         ptcb->OSTCBOpt       = opt;                        /* Store task options                       */
;         ptcb->OSTCBId        = id;                         /* Store task ID                            */
; #else
;         pext                 = pext;                       /* Prevent compiler warning if not used     */
	.dbline 1063
;         stk_size             = stk_size;
	movw R30,R28
	ldd R2,z+10
	ldd R3,z+11
	ldd R4,z+12
	ldd R5,z+13
	movw R30,R28
	std z+10,R2
	std z+11,R3
	std z+12,R4
	std z+13,R5
	.dbline 1064