URL https://opencores.org/ocsvn/c16/c16/trunk
Subversion Repositories c16

[/] [c16/] [trunk/] [rtos.asm] - Blame information for rev 33

Go to most recent revision | Details | Compare with Previous | View Log

IN_RX_DATA              = 0x00          ;
IN_STATUS               = 0x01          ;
IN_TEMPERAT             = 0x02          ;
IN_DIP_SWITCH           = 0x03          ;
IN_CLK_CTR_LOW          = 0x05          ;
IN_CLK_CTR_HIGH         = 0x06          ;
 
MEMTOP  =0x2000
 
OUT_TX_DATA             = 0x00          ;
OUT_LEDS                = 0x02          ;
OUT_INT_MASK            = 0x03          ;
OUT_RESET_TIMER         = 0x04          ;
OUT_START_CLK_CTR       = 0x05          ;
OUT_STOP_CLK_CTR        = 0x06          ;
;---------------------------------------;
        MOVE    #MEMTOP, RR             ;
        MOVE    RR, SP                  ;
        EI                              ;
        JMP     Cmain                   ;
        JMP     Cinterrupt              ;
;---------------------------------------;
mult_div:                               ;
        MD_STP                          ; 1
        MD_STP                          ; 2
        MD_STP                          ; 3
        MD_STP                          ; 4
        MD_STP                          ; 5
        MD_STP                          ; 6
        MD_STP                          ; 7
        MD_STP                          ; 8
        MD_STP                          ; 9
        MD_STP                          ; 10
        MD_STP                          ; 11
        MD_STP                          ; 12
        MD_STP                          ; 13
        MD_STP                          ; 14
        MD_STP                          ; 15
        MD_STP                          ; 16
        RET                             ;
;---------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (enum)
;;;     spec = anonymous enum (2000000)
;;;   } 1 TypeSpecifier (enum)
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = typedef struct '_task' (800001)
;;;     name = _task
;;;   } 1 TypeSpecifier (struct/union)
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = typedef struct '_semaphore' (800001)
;;;     name = _semaphore
;;;   } 1 TypeSpecifier (struct/union)
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = struct '_task' (800000)
;;;     name = _task
;;;   } 1 TypeSpecifier (struct/union)
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = extern 'Task' (4000002)
;;;     name = Task
;;;   } 1 TypeSpecifier (struct/union)
        .EXTERN Ccurrent_task
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = extern 'Task' (4000002)
;;;     name = Task
;;;   } 1 TypeSpecifier (struct/union)
        .EXTERN Ctask_idle
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = struct '_semaphore' (800000)
;;;     name = _semaphore
;;;   } 1 TypeSpecifier (struct/union)
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = 'Semaphore' (4000000)
;;;     name = Semaphore
;;;   } 1 TypeSpecifier (struct/union)
Crx_sema:                       ;
        .WORD   0
        .WORD   0
        .WORD   0
        .WORD   Cstr_0
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = 'Semaphore' (4000000)
;;;     name = Semaphore
;;;   } 1 TypeSpecifier (struct/union)
Ct2_control:                    ;
        .WORD   0
        .WORD   0
        .WORD   0
        .WORD   Cstr_1
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = 'Semaphore' (4000000)
;;;     name = Semaphore
;;;   } 1 TypeSpecifier (struct/union)
Ct3_control:                    ;
        .WORD   0
        .WORD   0
        .WORD   0
        .WORD   Cstr_2
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = 'Semaphore' (4000000)
;;;     name = Semaphore
;;;   } 1 TypeSpecifier (struct/union)
Cserial_out:                    ;
        .WORD   1
        .WORD   0
        .WORD   0
        .WORD   Cstr_3
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 Declaration
;;;   { 1 TypeSpecifier (struct/union)
;;;     spec = 'Semaphore' (4000000)
;;;     name = Semaphore
;;;   } 1 TypeSpecifier (struct/union)
Ctx_sema:                       ;
        .WORD   16
        .WORD   0
        .WORD   0
        .WORD   Cstr_4
;;; } 0 Declaration
;;; ------------------------------------;
;;; { 0 FunctionDefinition
;;;   { 1 TypeName
;;;     { 2 TypeSpecifier (all)
;;;       spec = void (10000)
;;;     } 2 TypeSpecifier (all)
;;;     { 2 List
;;;       { 3 DeclItem
;;;         what = DECL_NAME
;;;         name = switch_tasks
;;;       } 3 DeclItem
;;;     } 2 List
;;;   } 1 TypeName
;;;   { 1 List
;;;     { 2 DeclItem
;;;       what = DECL_NAME
;;;       name = switch_tasks
;;;     } 2 DeclItem
;;;     { 2 DeclItem
;;;       what = DECL_FUN
;;;     } 2 DeclItem
;;;   } 1 List
Cswitch_tasks:
;;;   { 1 CompoundStatement
;;;     { 2 InitDeclarator
;;;       { 3 List
;;;         { 4 DeclItem
;;;           what = DECL_POINTER
;;;           { 5 List
;;;             { 6 Ptr
;;;             } 6 Ptr
;;;           } 5 List
;;;         } 4 DeclItem
;;;         { 4 DeclItem
;;;           what = DECL_NAME
;;;           name = next
;;;         } 4 DeclItem
;;;       } 3 List
;;;       { 3 Initializer (skalar)
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;       } 3 Initializer (skalar)
;;;     } 2 InitDeclarator
;;;     { 2 InitDeclarator
;;;       { 3 List
;;;         { 4 DeclItem
;;;           what = DECL_POINTER
;;;           { 5 List
;;;             { 6 Ptr
;;;             } 6 Ptr
;;;           } 5 List
;;;         } 4 DeclItem
;;;         { 4 DeclItem
;;;           what = DECL_NAME
;;;           name = t
;;;         } 4 DeclItem
;;;       } 3 List
;;;       { 3 Initializer (skalar)
;;;         { 4 Expression (variable name)
;;;           expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;         } 4 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;       } 3 Initializer (skalar)
;;;     } 2 InitDeclarator
;;;     { 2 List
;;;       { 3 ExpressionStatement
 
st_loop:
        MOVE    0(SP), RR               ; RR = t
        MOVE    (RR), RR                ; RR = t->next_task
        MOVE    RR, 0(SP)               ; t  = t->next_task
        ADD     RR, #4                  ; RR = & t->status
        MOVE    (RR), RS                ; RR = t->status
        JMP     RRNZ, st_next_task      ; jump if (status != 0)
                                        ;
        MOVE    2(SP), RR               ; RR = next
        JMP     RRZ, st_accept          ; jump if (next == 0)
                                        ;
        ADD     RR, #5                  ; RR = & next->priority
        MOVE    (RR), RS                ; RR = next->priority
        MOVE    RR, LL                  ; LL = next->priority
        MOVE    0(SP), RR               ; RR = t
        ADD     RR, #5                  ; RR = & t->priority
        MOVE    (RR), RS                ; RR = t->priority
        SGT     LL, RR                  ; RR = (next->priority > t->priority)
        JMP     RRNZ, st_next_task      ; jump if (next->priority > t->priority)
st_accept:                              ;
        MOVE    0(SP), RR               ; RR = t
        MOVE    RR, 2(SP)               ; next = t
st_next_task:                           ;
        MOVE    0(SP), RR               ; RR = t
        MOVE    (Ccurrent_task), LL     ; LL = current_task
        SNE     LL, RR                  ; RR = (t != current_task)
        JMP     RRNZ, st_loop           ;
 
;;;       } 3 ExpressionStatement
;;;       { 3 IfElseStatement
;;;         { 4 Expr l != r
;;;           { 5 TypeName
;;;             { 6 TypeSpecifier (struct/union)
;;;               spec = struct '_task' (800000)
;;;               name = _task
;;;             } 6 TypeSpecifier (struct/union)
;;;             { 6 List
;;;               { 7 DeclItem
;;;                 what = DECL_POINTER
;;;                 { 8 List
;;;                   { 9 Ptr
;;;                   } 9 Ptr
;;;                 } 8 List
;;;               } 7 DeclItem
;;;               { 7 DeclItem
;;;                 what = DECL_NAME
;;;                 name = current_task
;;;               } 7 DeclItem
;;;             } 6 List
;;;           } 5 TypeName
;;;           { 5 Expression (variable name)
;;;             expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;           } 5 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;           { 5 Expression (variable name)
;;;             expr_type = "identifier" (next)
;--     load_rr_var next = -2(FP), SP at -4 (16 bit)
        MOVE    2(SP), RR
;;;           } 5 Expression (variable name)
;--     l != r
        SNE     LL, RR
;;;         } 4 Expr l != r
;--     branch_false
        JMP     RRZ, L2_endif_1
;;;         { 4 CompoundStatement
;;;           { 5 List
;;;             { 6 ExpressionStatement
;;;               { 7 Expr l = r
;;;                 { 8 TypeName
;;;                   { 9 TypeSpecifier (all)
;;;                     spec = int (80000)
;;;                   } 9 TypeSpecifier (all)
;;;                   { 9 List
;;;                     { 10 DeclItem
;;;                       what = DECL_POINTER
;;;                       { 11 List
;;;                         { 12 Ptr
;;;                         } 12 Ptr
;;;                       } 11 List
;;;                     } 10 DeclItem
;;;                     { 10 DeclItem
;;;                       what = DECL_NAME
;;;                       name = stack_pointer
;;;                     } 10 DeclItem
;;;                   } 9 List
;;;                 } 8 TypeName
;;;                 { 8 Expression (cast)r
        LEA  0(SP), RR
;;;                 } 8 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                 { 8 Expr * r
;;;                   { 9 Expression (variable name)
;;;                     expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                   } 9 Expression (variable name)
;;;                 } 8 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;               } 7 Expr l = r
;;;             } 6 ExpressionStatement
;;;             { 6 ExpressionStatement
;;;               { 7 Expr l = r
;;;                 { 8 TypeName
;;;                   { 9 TypeSpecifier (struct/union)
;;;                     spec = struct '_task' (800000)
;;;                     name = _task
;;;                   } 9 TypeSpecifier (struct/union)
;;;                   { 9 List
;;;                     { 10 DeclItem
;;;                       what = DECL_POINTER
;;;                       { 11 List
;;;                         { 12 Ptr
;;;                         } 12 Ptr
;;;                       } 11 List
;;;                     } 10 DeclItem
;;;                     { 10 DeclItem
;;;                       what = DECL_NAME
;;;                       name = current_task
;;;                     } 10 DeclItem
;;;                   } 9 List
;;;                 } 8 TypeName
;;;                 { 8 Expression (variable name)
;;;                   expr_type = "identifier" (next)
;--     load_rr_var next = -2(FP), SP at -4 (16 bit)
        MOVE    2(SP), RR
;;;                 } 8 Expression (variable name)
;--     store_rr_var current_task
        MOVE    RR, (Ccurrent_task)
;;;               } 7 Expr l = r
;;;             } 6 ExpressionStatement
;;;             { 6 ExpressionStatement
;;;               { 7 Expr * r
;;;                 { 8 Expression (variable name)
;;;                   expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                 } 8 Expression (variable name)
;;;               } 7 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;;;             } 6 ExpressionStatement
;;;             { 6 ExpressionStatement
        MOVE RR, SP
;;;             } 6 ExpressionStatement
;;;           } 5 List
;--     pop 0 bytes
;;;         } 4 CompoundStatement
L2_endif_1:
;;;       } 3 IfElseStatement
;;;     } 2 List
;--     pop 4 bytes
        ADD     SP, #4
;;;   } 1 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;   { 1 FunctionDefinition
;;;     { 2 TypeName
;;;       { 3 TypeSpecifier (all)
;;;         spec = void (10000)
;;;       } 3 TypeSpecifier (all)
;;;       { 3 List
;;;         { 4 DeclItem
;;;           what = DECL_NAME
;;;           name = P
;;;         } 4 DeclItem
;;;       } 3 List
;;;     } 2 TypeName
;;;     { 2 List
;;;       { 3 DeclItem
;;;         what = DECL_NAME
;;;         name = P
;;;       } 3 DeclItem
;;;       { 3 DeclItem
;;;         what = DECL_FUN
;;;         { 4 List
;;;           { 5 ParameterDeclaration
;;;             isEllipsis = false
;;;             { 6 TypeName
;;;               { 7 TypeSpecifier (struct/union)
;;;                 spec = struct '_semaphore' (800000)
;;;                 name = _semaphore
;;;               } 7 TypeSpecifier (struct/union)
;;;               { 7 List
;;;                 { 8 DeclItem
;;;                   what = DECL_POINTER
;;;                   { 9 List
;;;                     { 10 Ptr
;;;                     } 10 Ptr
;;;                   } 9 List
;;;                 } 8 DeclItem
;;;                 { 8 DeclItem
;;;                   what = DECL_NAME
;;;                   name = sema
;;;                 } 8 DeclItem
;;;               } 7 List
;;;             } 6 TypeName
;;;           } 5 ParameterDeclaration
;;;         } 4 List
;;;       } 3 DeclItem
;;;     } 2 List
CP:
;;;     { 2 CompoundStatement
;;;       { 3 List
;;;         { 4 ExpressionStatement
        DI
;;;         } 4 ExpressionStatement
;;;         { 4 IfElseStatement
;;;           { 5 Expr l < r
;;;             { 6 TypeName (internal)
;;;               { 7 TypeSpecifier (all)
;;;                 spec = int (80000)
;;;               } 7 TypeSpecifier (all)
;;;             } 6 TypeName (internal)
;;;             { 6 Expr --r
;;;               { 7 Expr * r
;;;                 { 8 Expression (variable name)
;;;                   expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                 } 8 Expression (variable name)
;;;               } 7 Expr * r
;--     + (member)
;--     move_rr_to_ll
        MOVE    RR, LL
;--     content
        MOVE    (RR), RR
;--     --
        SUB     RR, #0x0001
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;             } 6 Expr --r
;--     l < r
        SLT     RR, #0x0000
;;;           } 5 Expr l < r
;--     branch_false
        JMP     RRZ, L3_endif_2
;;;           { 5 CompoundStatement
;;;             { 6 List
;;;               { 7 ExpressionStatement
;;;                 { 8 Expr l = r
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (struct/union)
;;;                       spec = struct '_semaphore' (800000)
;;;                       name = _semaphore
;;;                     } 10 TypeSpecifier (struct/union)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_POINTER
;;;                         { 12 List
;;;                           { 13 Ptr
;;;                           } 13 Ptr
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = waiting_for
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;;;                   { 9 Expression (variable name)
;;;                     expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                   } 9 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                   { 9 Expr * r
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                     } 10 Expression (variable name)
;;;                   } 9 Expr * r
;--     + (member)
        ADD     RR, #0x000E
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                 } 8 Expr l = r
;;;               } 7 ExpressionStatement
;;;               { 7 ExpressionStatement
;;;                 { 8 Expr l = r
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (struct/union)
;;;                       spec = struct '_task' (800000)
;;;                       name = _task
;;;                     } 10 TypeSpecifier (struct/union)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_POINTER
;;;                         { 12 List
;;;                           { 13 Ptr
;;;                           } 13 Ptr
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = next_waiting_task
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;;;                   { 9 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                   } 9 NumericExpression (constant 0 = 0x0)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                   { 9 Expr * r
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                     } 10 Expression (variable name)
;;;                   } 9 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                 } 8 Expr l = r
;;;               } 7 ExpressionStatement
;;;               { 7 ExpressionStatement
;;;                 { 8 Expr l | r
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (all)
;;;                       spec = char (20000)
;;;                     } 10 TypeSpecifier (all)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = status
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;;;                   { 9 Expr l | r
;;;                     { 10 TypeName (internal)
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = int (80000)
;;;                       } 11 TypeSpecifier (all)
;;;                     } 10 TypeName (internal)
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l | r
        OR      RR, #0x0001
;;;                   } 9 Expr l | r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                   { 9 Expr * r
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                     } 10 Expression (variable name)
;;;                   } 9 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                 } 8 Expr l | r
;;;               } 7 ExpressionStatement
;;;               { 7 IfElseStatement
;;;                 { 8 Expr * r
;;;                   { 9 Expression (variable name)
;;;                     expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                   } 9 Expression (variable name)
;;;                 } 8 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     branch_false
        JMP     RRZ, L3_else_3
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l = r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (struct/union)
;;;                         spec = struct '_task' (800000)
;;;                         name = _task
;;;                       } 11 TypeSpecifier (struct/union)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_POINTER
;;;                           { 13 List
;;;                             { 14 Ptr
;;;                             } 14 Ptr
;;;                           } 13 List
;;;                         } 12 DeclItem
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = next_waiting_task
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                     } 10 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                     { 10 Expr * r
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RR
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                   } 9 Expr l = r
;;;                 } 8 ExpressionStatement
;--     branch
        JMP     L3_endif_3
L3_else_3:
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l = r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (struct/union)
;;;                         spec = struct '_task' (800000)
;;;                         name = _task
;;;                       } 11 TypeSpecifier (struct/union)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_POINTER
;;;                           { 13 List
;;;                             { 14 Ptr
;;;                             } 14 Ptr
;;;                           } 13 List
;;;                         } 12 DeclItem
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = next_waiting
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                     } 10 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                   } 9 Expr l = r
;;;                 } 8 ExpressionStatement
L3_endif_3:
;;;               } 7 IfElseStatement
;;;               { 7 ExpressionStatement
;;;                 { 8 Expr l = r
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (struct/union)
;;;                       spec = struct '_task' (800000)
;;;                       name = _task
;;;                     } 10 TypeSpecifier (struct/union)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_POINTER
;;;                         { 12 List
;;;                           { 13 Ptr
;;;                           } 13 Ptr
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = last_waiting
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;;;                   { 9 Expression (variable name)
;;;                     expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                   } 9 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                   { 9 Expr * r
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                     } 10 Expression (variable name)
;;;                   } 9 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                 } 8 Expr l = r
;;;               } 7 ExpressionStatement
;;;               { 7 ExpressionStatement
;;;                 { 8 Expr l(r)
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (all)
;;;                       spec = void (10000)
;;;                     } 10 TypeSpecifier (all)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = switch_tasks
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;--     push 0 bytes
;--     call
        CALL    Cswitch_tasks
;--     pop 0 bytes
;;;                 } 8 Expr l(r)
;;;               } 7 ExpressionStatement
;;;             } 6 List
;--     pop 0 bytes
;;;           } 5 CompoundStatement
L3_endif_2:
;;;         } 4 IfElseStatement
;;;         { 4 ExpressionStatement
        RETI
;;;         } 4 ExpressionStatement
;;;       } 3 List
;--     pop 0 bytes
;;;     } 2 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;     { 2 FunctionDefinition
;;;       { 3 TypeName
;;;         { 4 TypeSpecifier (all)
;;;           spec = char (20000)
;;;         } 4 TypeSpecifier (all)
;;;         { 4 List
;;;           { 5 DeclItem
;;;             what = DECL_NAME
;;;             name = P_timed
;;;           } 5 DeclItem
;;;         } 4 List
;;;       } 3 TypeName
;;;       { 3 List
;;;         { 4 DeclItem
;;;           what = DECL_NAME
;;;           name = P_timed
;;;         } 4 DeclItem
;;;         { 4 DeclItem
;;;           what = DECL_FUN
;;;           { 5 List
;;;             { 6 ParameterDeclaration
;;;               isEllipsis = false
;;;               { 7 TypeName
;;;                 { 8 TypeSpecifier (struct/union)
;;;                   spec = struct '_semaphore' (800000)
;;;                   name = _semaphore
;;;                 } 8 TypeSpecifier (struct/union)
;;;                 { 8 List
;;;                   { 9 DeclItem
;;;                     what = DECL_POINTER
;;;                     { 10 List
;;;                       { 11 Ptr
;;;                       } 11 Ptr
;;;                     } 10 List
;;;                   } 9 DeclItem
;;;                   { 9 DeclItem
;;;                     what = DECL_NAME
;;;                     name = sema
;;;                   } 9 DeclItem
;;;                 } 8 List
;;;               } 7 TypeName
;;;             } 6 ParameterDeclaration
;;;             { 6 ParameterDeclaration
;;;               isEllipsis = false
;;;               { 7 TypeName
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = unsigned int (82000)
;;;                 } 8 TypeSpecifier (all)
;;;                 { 8 List
;;;                   { 9 DeclItem
;;;                     what = DECL_NAME
;;;                     name = ticks
;;;                   } 9 DeclItem
;;;                 } 8 List
;;;               } 7 TypeName
;;;             } 6 ParameterDeclaration
;;;           } 5 List
;;;         } 4 DeclItem
;;;       } 3 List
CP_timed:
;;;       { 3 CompoundStatement
;;;         { 4 InitDeclarator
;;;           { 5 List
;;;             { 6 DeclItem
;;;               what = DECL_NAME
;;;               name = ret
;;;             } 6 DeclItem
;;;           } 5 List
;;;           { 5 Initializer (skalar)
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;           } 5 Initializer (skalar)
;;;         } 4 InitDeclarator
;;;         { 4 List
;;;           { 5 ExpressionStatement
        DI
;;;           } 5 ExpressionStatement
;;;           { 5 IfElseStatement
;;;             { 6 Expr l < r
;;;               { 7 TypeName (internal)
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = int (80000)
;;;                 } 8 TypeSpecifier (all)
;;;               } 7 TypeName (internal)
;;;               { 7 Expr --r
;;;                 { 8 Expr * r
;;;                   { 9 Expression (variable name)
;;;                     expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                   } 9 Expression (variable name)
;;;                 } 8 Expr * r
;--     + (member)
;--     move_rr_to_ll
        MOVE    RR, LL
;--     content
        MOVE    (RR), RR
;--     --
        SUB     RR, #0x0001
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;               } 7 Expr --r
;--     l < r
        SLT     RR, #0x0000
;;;             } 6 Expr l < r
;--     branch_false
        JMP     RRZ, L4_endif_4
;;;             { 6 CompoundStatement
;;;               { 7 List
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l = r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (struct/union)
;;;                         spec = struct '_semaphore' (800000)
;;;                         name = _semaphore
;;;                       } 11 TypeSpecifier (struct/union)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_POINTER
;;;                           { 13 List
;;;                             { 14 Ptr
;;;                             } 14 Ptr
;;;                           } 13 List
;;;                         } 12 DeclItem
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = waiting_for
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                     } 10 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x000E
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                   } 9 Expr l = r
;;;                 } 8 ExpressionStatement
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l = r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = int (80000)
;;;                       } 11 TypeSpecifier (all)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = sleep_count
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (ticks)
;--     load_rr_var ticks = 4(FP), SP at -1 (16 bit)
        MOVE    5(SP), RR
;;;                     } 10 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x0012
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                   } 9 Expr l = r
;;;                 } 8 ExpressionStatement
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l = r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (struct/union)
;;;                         spec = struct '_task' (800000)
;;;                         name = _task
;;;                       } 11 TypeSpecifier (struct/union)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_POINTER
;;;                           { 13 List
;;;                             { 14 Ptr
;;;                             } 14 Ptr
;;;                           } 13 List
;;;                         } 12 DeclItem
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = next_waiting_task
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                     } 10 NumericExpression (constant 0 = 0x0)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                   } 9 Expr l = r
;;;                 } 8 ExpressionStatement
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l | r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = char (20000)
;;;                       } 11 TypeSpecifier (all)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = status
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 Expr l | r
;;;                       { 11 TypeName (internal)
;;;                         { 12 TypeSpecifier (all)
;;;                           spec = int (80000)
;;;                         } 12 TypeSpecifier (all)
;;;                       } 11 TypeName (internal)
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l | r
        OR      RR, #0x0003
;;;                     } 10 Expr l | r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                   } 9 Expr l | r
;;;                 } 8 ExpressionStatement
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l = r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = char (20000)
;;;                       } 11 TypeSpecifier (all)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = sema_ret
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                     } 10 NumericExpression (constant 0 = 0x0)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x000C
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                   } 9 Expr l = r
;;;                 } 8 ExpressionStatement
;;;                 { 8 IfElseStatement
;;;                   { 9 Expr * r
;;;                     { 10 Expression (variable name)
;;;                       expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                     } 10 Expression (variable name)
;;;                   } 9 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     branch_false
        JMP     RRZ, L4_else_5
;;;                   { 9 ExpressionStatement
;;;                     { 10 Expr l = r
;;;                       { 11 TypeName
;;;                         { 12 TypeSpecifier (struct/union)
;;;                           spec = struct '_task' (800000)
;;;                           name = _task
;;;                         } 12 TypeSpecifier (struct/union)
;;;                         { 12 List
;;;                           { 13 DeclItem
;;;                             what = DECL_POINTER
;;;                             { 14 List
;;;                               { 15 Ptr
;;;                               } 15 Ptr
;;;                             } 14 List
;;;                           } 13 DeclItem
;;;                           { 13 DeclItem
;;;                             what = DECL_NAME
;;;                             name = next_waiting_task
;;;                           } 13 DeclItem
;;;                         } 12 List
;;;                       } 11 TypeName
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                       { 11 Expr * r
;;;                         { 12 Expr * r
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -3 (16 bit)
        MOVE    5(SP), RR
;;;                           } 13 Expression (variable name)
;;;                         } 12 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RR
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                     } 10 Expr l = r
;;;                   } 9 ExpressionStatement
;--     branch
        JMP     L4_endif_5
L4_else_5:
;;;                   { 9 ExpressionStatement
;;;                     { 10 Expr l = r
;;;                       { 11 TypeName
;;;                         { 12 TypeSpecifier (struct/union)
;;;                           spec = struct '_task' (800000)
;;;                           name = _task
;;;                         } 12 TypeSpecifier (struct/union)
;;;                         { 12 List
;;;                           { 13 DeclItem
;;;                             what = DECL_POINTER
;;;                             { 14 List
;;;                               { 15 Ptr
;;;                               } 15 Ptr
;;;                             } 14 List
;;;                           } 13 DeclItem
;;;                           { 13 DeclItem
;;;                             what = DECL_NAME
;;;                             name = next_waiting
;;;                           } 13 DeclItem
;;;                         } 12 List
;;;                       } 11 TypeName
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -3 (16 bit)
        MOVE    5(SP), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                     } 10 Expr l = r
;;;                   } 9 ExpressionStatement
L4_endif_5:
;;;                 } 8 IfElseStatement
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l(r)
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = void (10000)
;;;                       } 11 TypeSpecifier (all)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = switch_tasks
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;--     push 0 bytes
;--     call
        CALL    Cswitch_tasks
;--     pop 0 bytes
;;;                   } 9 Expr l(r)
;;;                 } 8 ExpressionStatement
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l = r
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = char (20000)
;;;                       } 11 TypeSpecifier (all)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = ret
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 Expr * r
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;;;                     } 10 Expr * r
;--     + (member)
        ADD     RR, #0x000C
;--     content
        MOVE    (RR), RS
;--     store_rr_var ret = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                   } 9 Expr l = r
;;;                 } 8 ExpressionStatement
;;;               } 7 List
;--     pop 0 bytes
;;;             } 6 CompoundStatement
L4_endif_4:
;;;           } 5 IfElseStatement
;;;           { 5 ExpressionStatement
        EI
;;;           } 5 ExpressionStatement
;;;           { 5 return Statement
;;;             { 6 Expression (variable name)
;;;               expr_type = "identifier" (ret)
;--     load_rr_var ret = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;             } 6 Expression (variable name)
;--     ret
        ADD     SP, #1
        RET
;;;           } 5 return Statement
;;;         } 4 List
;--     pop 1 bytes
        ADD     SP, #1
;;;       } 3 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;       { 3 FunctionDefinition
;;;         { 4 TypeName
;;;           { 5 TypeSpecifier (all)
;;;             spec = char (20000)
;;;           } 5 TypeSpecifier (all)
;;;           { 5 List
;;;             { 6 DeclItem
;;;               what = DECL_NAME
;;;               name = Vint
;;;             } 6 DeclItem
;;;           } 5 List
;;;         } 4 TypeName
;;;         { 4 List
;;;           { 5 DeclItem
;;;             what = DECL_NAME
;;;             name = Vint
;;;           } 5 DeclItem
;;;           { 5 DeclItem
;;;             what = DECL_FUN
;;;             { 6 List
;;;               { 7 ParameterDeclaration
;;;                 isEllipsis = false
;;;                 { 8 TypeName
;;;                   { 9 TypeSpecifier (struct/union)
;;;                     spec = struct '_semaphore' (800000)
;;;                     name = _semaphore
;;;                   } 9 TypeSpecifier (struct/union)
;;;                   { 9 List
;;;                     { 10 DeclItem
;;;                       what = DECL_POINTER
;;;                       { 11 List
;;;                         { 12 Ptr
;;;                         } 12 Ptr
;;;                       } 11 List
;;;                     } 10 DeclItem
;;;                     { 10 DeclItem
;;;                       what = DECL_NAME
;;;                       name = sema
;;;                     } 10 DeclItem
;;;                   } 9 List
;;;                 } 8 TypeName
;;;               } 7 ParameterDeclaration
;;;             } 6 List
;;;           } 5 DeclItem
;;;         } 4 List
CVint:
;;;         { 4 CompoundStatement
;;;           { 5 InitDeclarator
;;;             { 6 List
;;;               { 7 DeclItem
;;;                 what = DECL_POINTER
;;;                 { 8 List
;;;                   { 9 Ptr
;;;                   } 9 Ptr
;;;                 } 8 List
;;;               } 7 DeclItem
;;;               { 7 DeclItem
;;;                 what = DECL_NAME
;;;                 name = next
;;;               } 7 DeclItem
;;;             } 6 List
;;;             { 6 Initializer (skalar)
;;;               { 7 Expr * r
;;;                 { 8 Expression (variable name)
;;;                   expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                 } 8 Expression (variable name)
;;;               } 7 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;             } 6 Initializer (skalar)
;;;           } 5 InitDeclarator
;;;           { 5 List
;;;             { 6 ExpressionStatement
;;;               { 7 Expr ++r
;;;                 { 8 Expr * r
;;;                   { 9 Expression (variable name)
;;;                     expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                   } 9 Expression (variable name)
;;;                 } 8 Expr * r
;--     + (member)
;--     move_rr_to_ll
        MOVE    RR, LL
;--     content
        MOVE    (RR), RR
;--     ++
        ADD     RR, #0x0001
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;               } 7 Expr ++r
;;;             } 6 ExpressionStatement
;;;             { 6 IfElseStatement
;;;               { 7 Expression (variable name)
;;;                 expr_type = "identifier" (next)
;--     load_rr_var next = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;               } 7 Expression (variable name)
;--     branch_false
        JMP     RRZ, L5_endif_6
;;;               { 7 CompoundStatement
;;;                 { 8 List
;;;                   { 9 ExpressionStatement
;;;                     { 10 Expr l & r
;;;                       { 11 TypeName
;;;                         { 12 TypeSpecifier (all)
;;;                           spec = char (20000)
;;;                         } 12 TypeSpecifier (all)
;;;                         { 12 List
;;;                           { 13 DeclItem
;;;                             what = DECL_NAME
;;;                             name = status
;;;                           } 13 DeclItem
;;;                         } 12 List
;;;                       } 11 TypeName
;;;                       { 11 Expr l & r
;;;                         { 12 TypeName (internal)
;;;                           { 13 TypeSpecifier (all)
;;;                             spec = int (80000)
;;;                           } 13 TypeSpecifier (all)
;;;                         } 12 TypeName (internal)
;;;                         { 12 Expr * r
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (next)
;--     load_rr_var next = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                           } 13 Expression (variable name)
;;;                         } 12 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0xFFFC
;;;                       } 11 Expr l & r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (next)
;--     load_rr_var next = -2(FP), SP at -3 (16 bit)
        MOVE    1(SP), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                     } 10 Expr l & r
;;;                   } 9 ExpressionStatement
;;;                   { 9 ExpressionStatement
;;;                     { 10 Expr l = r
;;;                       { 11 TypeName
;;;                         { 12 TypeSpecifier (struct/union)
;;;                           spec = struct '_task' (800000)
;;;                           name = _task
;;;                         } 12 TypeSpecifier (struct/union)
;;;                         { 12 List
;;;                           { 13 DeclItem
;;;                             what = DECL_POINTER
;;;                             { 14 List
;;;                               { 15 Ptr
;;;                               } 15 Ptr
;;;                             } 14 List
;;;                           } 13 DeclItem
;;;                           { 13 DeclItem
;;;                             what = DECL_NAME
;;;                             name = next_waiting
;;;                           } 13 DeclItem
;;;                         } 12 List
;;;                       } 11 TypeName
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (next)
;--     load_rr_var next = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -4 (16 bit)
        MOVE    6(SP), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                     } 10 Expr l = r
;;;                   } 9 ExpressionStatement
;;;                   { 9 IfElseStatement
;;;                     { 10 Expr ! r
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     16 bit ! r
        LNOT    RR
;;;                     } 10 Expr ! r
;--     branch_false
        JMP     RRZ, L5_endif_7
;;;                     { 10 ExpressionStatement
;;;                       { 11 Expr l = r
;;;                         { 12 TypeName
;;;                           { 13 TypeSpecifier (struct/union)
;;;                             spec = struct '_task' (800000)
;;;                             name = _task
;;;                           } 13 TypeSpecifier (struct/union)
;;;                           { 13 List
;;;                             { 14 DeclItem
;;;                               what = DECL_POINTER
;;;                               { 15 List
;;;                                 { 16 Ptr
;;;                                 } 16 Ptr
;;;                               } 15 List
;;;                             } 14 DeclItem
;;;                             { 14 DeclItem
;;;                               what = DECL_NAME
;;;                               name = last_waiting
;;;                             } 14 DeclItem
;;;                           } 13 List
;;;                         } 12 TypeName
;;;                         { 12 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                         } 12 NumericExpression (constant 0 = 0x0)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                         { 12 Expr * r
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at -4 (16 bit)
        MOVE    6(SP), RR
;;;                           } 13 Expression (variable name)
;;;                         } 12 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                       } 11 Expr l = r
;;;                     } 10 ExpressionStatement
L5_endif_7:
;;;                   } 9 IfElseStatement
;;;                   { 9 return Statement
;;;                     { 10 Expr l > r
;;;                       { 11 TypeName (internal)
;;;                         { 12 TypeSpecifier (all)
;;;                           spec = unsigned int (82000)
;;;                         } 12 TypeSpecifier (all)
;;;                       } 11 TypeName (internal)
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (next)
;--     load_rr_var next = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0005
;--     content
        MOVE    (RR), RU
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                       { 11 Expr * r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                         } 12 Expression (variable name)
;;;                       } 11 Expr * r
;--     + (member)
        ADD     RR, #0x0005
;--     content
        MOVE    (RR), RU
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     l > r
        SHI     LL, RR
;;;                     } 10 Expr l > r
;--     ret
        ADD     SP, #2
        RET
;;;                   } 9 return Statement
;;;                 } 8 List
;--     pop 0 bytes
;;;               } 7 CompoundStatement
L5_endif_6:
;;;             } 6 IfElseStatement
;;;             { 6 return Statement
;;;               { 7 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;               } 7 NumericExpression (constant 0 = 0x0)
;--     ret
        ADD     SP, #2
        RET
;;;             } 6 return Statement
;;;           } 5 List
;--     pop 2 bytes
        ADD     SP, #2
;;;         } 4 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;         { 4 FunctionDefinition
;;;           { 5 TypeName
;;;             { 6 TypeSpecifier (all)
;;;               spec = void (10000)
;;;             } 6 TypeSpecifier (all)
;;;             { 6 List
;;;               { 7 DeclItem
;;;                 what = DECL_NAME
;;;                 name = V
;;;               } 7 DeclItem
;;;             } 6 List
;;;           } 5 TypeName
;;;           { 5 List
;;;             { 6 DeclItem
;;;               what = DECL_NAME
;;;               name = V
;;;             } 6 DeclItem
;;;             { 6 DeclItem
;;;               what = DECL_FUN
;;;               { 7 List
;;;                 { 8 ParameterDeclaration
;;;                   isEllipsis = false
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (struct/union)
;;;                       spec = struct '_semaphore' (800000)
;;;                       name = _semaphore
;;;                     } 10 TypeSpecifier (struct/union)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_POINTER
;;;                         { 12 List
;;;                           { 13 Ptr
;;;                           } 13 Ptr
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = sema
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;;;                 } 8 ParameterDeclaration
;;;               } 7 List
;;;             } 6 DeclItem
;;;           } 5 List
CV:
;;;           { 5 CompoundStatement
;;;             { 6 List
;;;               { 7 ExpressionStatement
        DI
;;;               } 7 ExpressionStatement
;;;               { 7 IfElseStatement
;;;                 { 8 Expr l(r)
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (all)
;;;                       spec = char (20000)
;;;                     } 10 TypeSpecifier (all)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = Vint
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;;;                   { 9 ParameterDeclaration
;;;                     isEllipsis = false
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (struct/union)
;;;                         spec = struct '_semaphore' (800000)
;;;                         name = _semaphore
;;;                       } 11 TypeSpecifier (struct/union)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_POINTER
;;;                           { 13 List
;;;                             { 14 Ptr
;;;                             } 14 Ptr
;;;                           } 13 List
;;;                         } 12 DeclItem
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = sema
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                   } 9 ParameterDeclaration
;;;                   { 9 Expression (variable name)
;;;                     expr_type = "identifier" (sema)
;--     load_rr_var sema = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                   } 9 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 1 bytes
;--     call
        CALL    CVint
;--     pop 2 bytes
        ADD     SP, #2
;;;                 } 8 Expr l(r)
;--     branch_false
        JMP     RRZ, L6_endif_8
;;;                 { 8 ExpressionStatement
;;;                   { 9 Expr l(r)
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = void (10000)
;;;                       } 11 TypeSpecifier (all)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = switch_tasks
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;--     push 0 bytes
;--     call
        CALL    Cswitch_tasks
;--     pop 0 bytes
;;;                   } 9 Expr l(r)
;;;                 } 8 ExpressionStatement
L6_endif_8:
;;;               } 7 IfElseStatement
;;;               { 7 ExpressionStatement
        RETI
;;;               } 7 ExpressionStatement
;;;             } 6 List
;--     pop 0 bytes
;;;           } 5 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;           { 5 Declaration
;;;             { 6 TypeSpecifier (all)
;;;               spec = unsigned char (22000)
;;;             } 6 TypeSpecifier (all)
Cserial_in_buffer:                      ;
        .BYTE   0                        ; VOID [0]
        .BYTE   0                        ; VOID [1]
        .BYTE   0                        ; VOID [2]
        .BYTE   0                        ; VOID [3]
        .BYTE   0                        ; VOID [4]
        .BYTE   0                        ; VOID [5]
        .BYTE   0                        ; VOID [6]
        .BYTE   0                        ; VOID [7]
        .BYTE   0                        ; VOID [8]
        .BYTE   0                        ; VOID [9]
        .BYTE   0                        ; VOID [10]
        .BYTE   0                        ; VOID [11]
        .BYTE   0                        ; VOID [12]
        .BYTE   0                        ; VOID [13]
        .BYTE   0                        ; VOID [14]
        .BYTE   0                        ; VOID [15]
;;;           } 5 Declaration
;;; ------------------------------------;
;;;           { 5 Declaration
;;;             { 6 TypeSpecifier (all)
;;;               spec = unsigned char (22000)
;;;             } 6 TypeSpecifier (all)
Cserial_in_get:                 ;
        .BYTE   0
;;;           } 5 Declaration
;;; ------------------------------------;
;;;           { 5 Declaration
;;;             { 6 TypeSpecifier (all)
;;;               spec = unsigned char (22000)
;;;             } 6 TypeSpecifier (all)
Cserial_in_put:                 ;
        .BYTE   0
;;;           } 5 Declaration
;;; ------------------------------------;
;;;           { 5 Declaration
;;;             { 6 TypeSpecifier (all)
;;;               spec = unsigned int (82000)
;;;             } 6 TypeSpecifier (all)
Cserial_in_overflows:                   ;
        .WORD   0
;;;           } 5 Declaration
;;; ------------------------------------;
;;;           { 5 FunctionDefinition
;;;             { 6 TypeName
;;;               { 7 TypeSpecifier (all)
;;;                 spec = char (20000)
;;;               } 7 TypeSpecifier (all)
;;;               { 7 List
;;;                 { 8 DeclItem
;;;                   what = DECL_NAME
;;;                   name = rx_interrupt
;;;                 } 8 DeclItem
;;;               } 7 List
;;;             } 6 TypeName
;;;             { 6 List
;;;               { 7 DeclItem
;;;                 what = DECL_NAME
;;;                 name = rx_interrupt
;;;               } 7 DeclItem
;;;               { 7 DeclItem
;;;                 what = DECL_FUN
;;;               } 7 DeclItem
;;;             } 6 List
Crx_interrupt:
;;;             { 6 CompoundStatement
;;;               { 7 InitDeclarator
;;;                 { 8 List
;;;                   { 9 DeclItem
;;;                     what = DECL_NAME
;;;                     name = c
;;;                   } 9 DeclItem
;;;                 } 8 List
;;;                 { 8 Initializer (skalar)
        IN   (IN_RX_DATA), RU
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                 } 8 Initializer (skalar)
;;;               } 7 InitDeclarator
;;;               { 7 List
;;;                 { 8 IfElseStatement
;;;                   { 9 Expr l < r
;;;                     { 10 TypeName (internal)
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = int (80000)
;;;                       } 11 TypeSpecifier (all)
;;;                     } 10 TypeName (internal)
;--     load_address rx_sema
        MOVE    #Crx_sema, RR
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     l < r
        SLT     RR, #0x0010
;;;                   } 9 Expr l < r
;--     branch_false
        JMP     RRZ, L7_else_9
;;;                   { 9 CompoundStatement
;;;                     { 10 List
;;;                       { 11 ExpressionStatement
;;;                         { 12 Expr l = r
;;;                           { 13 TypeName
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = unsigned char (22000)
;;;                             } 14 TypeSpecifier (all)
;;;                             { 14 List
;;;                               { 15 DeclItem
;;;                                 what = DECL_NAME
;;;                                 name = serial_in_buffer
;;;                               } 15 DeclItem
;;;                             } 14 List
;;;                           } 13 TypeName
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                           } 13 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                           { 13 Expr l[r]
;;;                             { 14 Expression (variable name)
;;;                               expr_type = "identifier" (serial_in_put)
;--     load_rr_var serial_in_put, (8 bit)
        MOVE    (Cserial_in_put), RU
;;;                             } 14 Expression (variable name)
;--     scale_rr *1
;--     add_address serial_in_buffer
        ADD     RR, #Cserial_in_buffer
;;;                           } 13 Expr l[r]
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RU
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                         } 12 Expr l = r
;;;                       } 11 ExpressionStatement
;;;                       { 11 IfElseStatement
;;;                         { 12 Expr l >= r
;;;                           { 13 TypeName (internal)
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = unsigned int (82000)
;;;                             } 14 TypeSpecifier (all)
;;;                           } 13 TypeName (internal)
;;;                           { 13 Expr ++r
;;;                             { 14 Expression (variable name)
;;;                               expr_type = "identifier" (serial_in_put)
;--     load_rr_var serial_in_put, (8 bit)
        MOVE    (Cserial_in_put), RU
;;;                             } 14 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var serial_in_put
        MOVE    R, (Cserial_in_put)
;;;                           } 13 Expr ++r
;--     l >= r
        SHS     RR, #0x0010
;;;                         } 12 Expr l >= r
;--     branch_false
        JMP     RRZ, L7_endif_10
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l = r
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = unsigned char (22000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = serial_in_put
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                             } 14 NumericExpression (constant 0 = 0x0)
;--     store_rr_var serial_in_put
        MOVE    R, (Cserial_in_put)
;;;                           } 13 Expr l = r
;;;                         } 12 ExpressionStatement
L7_endif_10:
;;;                       } 11 IfElseStatement
;;;                       { 11 return Statement
;;;                         { 12 Expr l(r)
;;;                           { 13 TypeName
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = char (20000)
;;;                             } 14 TypeSpecifier (all)
;;;                             { 14 List
;;;                               { 15 DeclItem
;;;                                 what = DECL_NAME
;;;                                 name = Vint
;;;                               } 15 DeclItem
;;;                             } 14 List
;;;                           } 13 TypeName
;;;                           { 13 ParameterDeclaration
;;;                             isEllipsis = false
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (struct/union)
;;;                                 spec = struct '_semaphore' (800000)
;;;                                 name = _semaphore
;;;                               } 15 TypeSpecifier (struct/union)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_POINTER
;;;                                   { 17 List
;;;                                     { 18 Ptr
;;;                                     } 18 Ptr
;;;                                   } 17 List
;;;                                 } 16 DeclItem
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = sema
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                           } 13 ParameterDeclaration
;;;                           { 13 Expr & r
;--     load_address rx_sema
        MOVE    #Crx_sema, RR
;;;                           } 13 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 1 bytes
;--     call
        CALL    CVint
;--     pop 2 bytes
        ADD     SP, #2
;;;                         } 12 Expr l(r)
;--     ret
        ADD     SP, #1
        RET
;;;                       } 11 return Statement
;;;                     } 10 List
;--     pop 0 bytes
;;;                   } 9 CompoundStatement
;--     branch
        JMP     L7_endif_9
L7_else_9:
;;;                   { 9 CompoundStatement
;;;                     { 10 List
;;;                       { 11 ExpressionStatement
;;;                         { 12 Expr ++r
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (serial_in_overflows)
;--     load_rr_var serial_in_overflows, (16 bit)
        MOVE    (Cserial_in_overflows), RR
;;;                           } 13 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var serial_in_overflows
        MOVE    RR, (Cserial_in_overflows)
;;;                         } 12 Expr ++r
;;;                       } 11 ExpressionStatement
;;;                       { 11 return Statement
;;;                         { 12 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                         } 12 NumericExpression (constant 0 = 0x0)
;--     ret
        ADD     SP, #1
        RET
;;;                       } 11 return Statement
;;;                     } 10 List
;--     pop 0 bytes
;;;                   } 9 CompoundStatement
L7_endif_9:
;;;                 } 8 IfElseStatement
;;;               } 7 List
;--     pop 1 bytes
        ADD     SP, #1
;;;             } 6 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;             { 6 Declaration
;;;               { 7 TypeSpecifier (all)
;;;                 spec = unsigned char (22000)
;;;               } 7 TypeSpecifier (all)
Cserial_out_buffer:                     ;
        .BYTE   0                        ; VOID [0]
        .BYTE   0                        ; VOID [1]
        .BYTE   0                        ; VOID [2]
        .BYTE   0                        ; VOID [3]
        .BYTE   0                        ; VOID [4]
        .BYTE   0                        ; VOID [5]
        .BYTE   0                        ; VOID [6]
        .BYTE   0                        ; VOID [7]
        .BYTE   0                        ; VOID [8]
        .BYTE   0                        ; VOID [9]
        .BYTE   0                        ; VOID [10]
        .BYTE   0                        ; VOID [11]
        .BYTE   0                        ; VOID [12]
        .BYTE   0                        ; VOID [13]
        .BYTE   0                        ; VOID [14]
        .BYTE   0                        ; VOID [15]
;;;             } 6 Declaration
;;; ------------------------------------;
;;;             { 6 Declaration
;;;               { 7 TypeSpecifier (all)
;;;                 spec = unsigned char (22000)
;;;               } 7 TypeSpecifier (all)
Cserial_out_get:                        ;
        .BYTE   0
;;;             } 6 Declaration
;;; ------------------------------------;
;;;             { 6 Declaration
;;;               { 7 TypeSpecifier (all)
;;;                 spec = unsigned char (22000)
;;;               } 7 TypeSpecifier (all)
Cserial_out_put:                        ;
        .BYTE   0
;;;             } 6 Declaration
;;; ------------------------------------;
;;;             { 6 FunctionDefinition
;;;               { 7 TypeName
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = char (20000)
;;;                 } 8 TypeSpecifier (all)
;;;                 { 8 List
;;;                   { 9 DeclItem
;;;                     what = DECL_NAME
;;;                     name = tx_interrupt
;;;                   } 9 DeclItem
;;;                 } 8 List
;;;               } 7 TypeName
;;;               { 7 List
;;;                 { 8 DeclItem
;;;                   what = DECL_NAME
;;;                   name = tx_interrupt
;;;                 } 8 DeclItem
;;;                 { 8 DeclItem
;;;                   what = DECL_FUN
;;;                 } 8 DeclItem
;;;               } 7 List
Ctx_interrupt:
;;;               { 7 CompoundStatement
;;;                 { 8 List
;;;                   { 9 IfElseStatement
;;;                     { 10 Expr l < r
;;;                       { 11 TypeName (internal)
;;;                         { 12 TypeSpecifier (all)
;;;                           spec = int (80000)
;;;                         } 12 TypeSpecifier (all)
;;;                       } 11 TypeName (internal)
;--     load_address tx_sema
        MOVE    #Ctx_sema, RR
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     l < r
        SLT     RR, #0x0010
;;;                     } 10 Expr l < r
;--     branch_false
        JMP     RRZ, L8_else_11
;;;                     { 10 CompoundStatement
;;;                       { 11 List
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l[r]
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = unsigned char (22000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = serial_out_buffer
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 Expr l[r]
;;;                               { 15 Expression (variable name)
;;;                                 expr_type = "identifier" (serial_out_get)
;--     load_rr_var serial_out_get, (8 bit)
        MOVE    (Cserial_out_get), RU
;;;                               } 15 Expression (variable name)
;--     scale_rr *1
;--     add_address serial_out_buffer
        ADD     RR, #Cserial_out_buffer
;;;                             } 14 Expr l[r]
;--     content
        MOVE    (RR), RU
;;;                           } 13 Expr l[r]
;;;                         } 12 ExpressionStatement
;;;                         { 12 ExpressionStatement
        OUT  R, (OUT_TX_DATA)
;;;                         } 12 ExpressionStatement
;;;                         { 12 IfElseStatement
;;;                           { 13 Expr l >= r
;;;                             { 14 TypeName (internal)
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = unsigned int (82000)
;;;                               } 15 TypeSpecifier (all)
;;;                             } 14 TypeName (internal)
;;;                             { 14 Expr ++r
;;;                               { 15 Expression (variable name)
;;;                                 expr_type = "identifier" (serial_out_get)
;--     load_rr_var serial_out_get, (8 bit)
        MOVE    (Cserial_out_get), RU
;;;                               } 15 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var serial_out_get
        MOVE    R, (Cserial_out_get)
;;;                             } 14 Expr ++r
;--     l >= r
        SHS     RR, #0x0010
;;;                           } 13 Expr l >= r
;--     branch_false
        JMP     RRZ, L8_endif_12
;;;                           { 13 ExpressionStatement
;;;                             { 14 Expr l = r
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = unsigned char (22000)
;;;                                 } 16 TypeSpecifier (all)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = serial_out_get
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;;;                               { 15 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                               } 15 NumericExpression (constant 0 = 0x0)
;--     store_rr_var serial_out_get
        MOVE    R, (Cserial_out_get)
;;;                             } 14 Expr l = r
;;;                           } 13 ExpressionStatement
L8_endif_12:
;;;                         } 12 IfElseStatement
;;;                         { 12 return Statement
;;;                           { 13 Expr l(r)
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = char (20000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = Vint
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 ParameterDeclaration
;;;                               isEllipsis = false
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (struct/union)
;;;                                   spec = struct '_semaphore' (800000)
;;;                                   name = _semaphore
;;;                                 } 16 TypeSpecifier (struct/union)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_POINTER
;;;                                     { 18 List
;;;                                       { 19 Ptr
;;;                                       } 19 Ptr
;;;                                     } 18 List
;;;                                   } 17 DeclItem
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = sema
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;;;                             } 14 ParameterDeclaration
;;;                             { 14 Expr & r
;--     load_address tx_sema
        MOVE    #Ctx_sema, RR
;;;                             } 14 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 1 bytes
;--     call
        CALL    CVint
;--     pop 2 bytes
        ADD     SP, #2
;;;                           } 13 Expr l(r)
;--     ret
        RET
;;;                         } 12 return Statement
;;;                       } 11 List
;--     pop 0 bytes
;;;                     } 10 CompoundStatement
;--     branch
        JMP     L8_endif_11
L8_else_11:
;;;                     { 10 CompoundStatement
;;;                       { 11 List
;;;                         { 12 ExpressionStatement
        MOVE #0x05, RR
;;;                         } 12 ExpressionStatement
;;;                         { 12 ExpressionStatement
        OUT  R, (OUT_INT_MASK)
;;;                         } 12 ExpressionStatement
;;;                         { 12 return Statement
;;;                           { 13 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                           } 13 NumericExpression (constant 0 = 0x0)
;--     ret
        RET
;;;                         } 12 return Statement
;;;                       } 11 List
;--     pop 0 bytes
;;;                     } 10 CompoundStatement
L8_endif_11:
;;;                   } 9 IfElseStatement
;;;                 } 8 List
;--     pop 0 bytes
;;;               } 7 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;               { 7 Declaration
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = unsigned int (82000)
;;;                 } 8 TypeSpecifier (all)
Cmilliseconds:                  ;
        .WORD   0
;;;               } 7 Declaration
;;; ------------------------------------;
;;;               { 7 Declaration
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = unsigned int (82000)
;;;                 } 8 TypeSpecifier (all)
Cseconds_low:                   ;
        .WORD   0
;;;               } 7 Declaration
;;; ------------------------------------;
;;;               { 7 Declaration
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = unsigned int (82000)
;;;                 } 8 TypeSpecifier (all)
Cseconds_mid:                   ;
        .WORD   0
;;;               } 7 Declaration
;;; ------------------------------------;
;;;               { 7 Declaration
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = unsigned int (82000)
;;;                 } 8 TypeSpecifier (all)
Cseconds_high:                  ;
        .WORD   0
;;;               } 7 Declaration
;;; ------------------------------------;
;;;               { 7 Declaration
;;;                 { 8 TypeSpecifier (all)
;;;                   spec = unsigned char (22000)
;;;                 } 8 TypeSpecifier (all)
Cseconds_changed:                       ;
        .BYTE   0
;;;               } 7 Declaration
;;; ------------------------------------;
;;;               { 7 FunctionDefinition
;;;                 { 8 TypeName
;;;                   { 9 TypeSpecifier (all)
;;;                     spec = void (10000)
;;;                   } 9 TypeSpecifier (all)
;;;                   { 9 List
;;;                     { 10 DeclItem
;;;                       what = DECL_NAME
;;;                       name = timer_interrupt
;;;                     } 10 DeclItem
;;;                   } 9 List
;;;                 } 8 TypeName
;;;                 { 8 List
;;;                   { 9 DeclItem
;;;                     what = DECL_NAME
;;;                     name = timer_interrupt
;;;                   } 9 DeclItem
;;;                   { 9 DeclItem
;;;                     what = DECL_FUN
;;;                   } 9 DeclItem
;;;                 } 8 List
Ctimer_interrupt:
;;;                 { 8 CompoundStatement
;;;                   { 9 InitDeclarator
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_POINTER
;;;                         { 12 List
;;;                           { 13 Ptr
;;;                           } 13 Ptr
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = t
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                     { 10 Initializer (skalar)
;;;                       { 11 Expression (variable name)
;;;                         expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                       } 11 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                     } 10 Initializer (skalar)
;;;                   } 9 InitDeclarator
;;;                   { 9 InitDeclarator
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_POINTER
;;;                         { 12 List
;;;                           { 13 Ptr
;;;                           } 13 Ptr
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = s
;;;                       } 11 DeclItem
;;;                     } 10 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                   } 9 InitDeclarator
;;;                   { 9 InitDeclarator
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_POINTER
;;;                         { 12 List
;;;                           { 13 Ptr
;;;                           } 13 Ptr
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = ts
;;;                       } 11 DeclItem
;;;                     } 10 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                   } 9 InitDeclarator
;;;                   { 9 List
;;;                     { 10 ExpressionStatement
        OUT  R, (OUT_RESET_TIMER)
;;;                     } 10 ExpressionStatement
;;;                     { 10 IfElseStatement
;;;                       { 11 Expr l == r
;;;                         { 12 TypeName (internal)
;;;                           { 13 TypeSpecifier (all)
;;;                             spec = unsigned int (82000)
;;;                           } 13 TypeSpecifier (all)
;;;                         } 12 TypeName (internal)
;;;                         { 12 Expr ++r
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (milliseconds)
;--     load_rr_var milliseconds, (16 bit)
        MOVE    (Cmilliseconds), RR
;;;                           } 13 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var milliseconds
        MOVE    RR, (Cmilliseconds)
;;;                         } 12 Expr ++r
;--     l == r
        SEQ     RR, #0x03E8
;;;                       } 11 Expr l == r
;--     branch_false
        JMP     RRZ, L9_endif_13
;;;                       { 11 CompoundStatement
;;;                         { 12 List
;;;                           { 13 ExpressionStatement
;;;                             { 14 Expr l = r
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = unsigned int (82000)
;;;                                 } 16 TypeSpecifier (all)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = milliseconds
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;;;                               { 15 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                               } 15 NumericExpression (constant 0 = 0x0)
;--     store_rr_var milliseconds
        MOVE    RR, (Cmilliseconds)
;;;                             } 14 Expr l = r
;;;                           } 13 ExpressionStatement
;;;                           { 13 ExpressionStatement
;;;                             { 14 Expr l = r
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = unsigned char (22000)
;;;                                 } 16 TypeSpecifier (all)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = seconds_changed
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;;;                               { 15 NumericExpression (constant 255 = 0xFF)
;--     load_rr_constant
        MOVE    #0x00FF, RR
;;;                               } 15 NumericExpression (constant 255 = 0xFF)
;--     store_rr_var seconds_changed
        MOVE    R, (Cseconds_changed)
;;;                             } 14 Expr l = r
;;;                           } 13 ExpressionStatement
;;;                           { 13 IfElseStatement
;;;                             { 14 Expr l == r
;;;                               { 15 TypeName (internal)
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = unsigned int (82000)
;;;                                 } 16 TypeSpecifier (all)
;;;                               } 15 TypeName (internal)
;;;                               { 15 Expr ++r
;;;                                 { 16 Expression (variable name)
;;;                                   expr_type = "identifier" (seconds_low)
;--     load_rr_var seconds_low, (16 bit)
        MOVE    (Cseconds_low), RR
;;;                                 } 16 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var seconds_low
        MOVE    RR, (Cseconds_low)
;;;                               } 15 Expr ++r
;--     l == r
        SEQ     RR, #0x0000
;;;                             } 14 Expr l == r
;--     branch_false
        JMP     RRZ, L9_endif_14
;;;                             { 14 CompoundStatement
;;;                               { 15 List
;;;                                 { 16 IfElseStatement
;;;                                   { 17 Expr l == r
;;;                                     { 18 TypeName (internal)
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = unsigned int (82000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                     } 18 TypeName (internal)
;;;                                     { 18 Expr ++r
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (seconds_mid)
;--     load_rr_var seconds_mid, (16 bit)
        MOVE    (Cseconds_mid), RR
;;;                                       } 19 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var seconds_mid
        MOVE    RR, (Cseconds_mid)
;;;                                     } 18 Expr ++r
;--     l == r
        SEQ     RR, #0x0000
;;;                                   } 17 Expr l == r
;--     branch_false
        JMP     RRZ, L9_endif_15
;;;                                   { 17 ExpressionStatement
;;;                                     { 18 Expr ++r
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (seconds_high)
;--     load_rr_var seconds_high, (16 bit)
        MOVE    (Cseconds_high), RR
;;;                                       } 19 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var seconds_high
        MOVE    RR, (Cseconds_high)
;;;                                     } 18 Expr ++r
;;;                                   } 17 ExpressionStatement
L9_endif_15:
;;;                                 } 16 IfElseStatement
;;;                               } 15 List
;--     pop 0 bytes
;;;                             } 14 CompoundStatement
L9_endif_14:
;;;                           } 13 IfElseStatement
;;;                         } 12 List
;--     pop 0 bytes
;;;                       } 11 CompoundStatement
L9_endif_13:
;;;                     } 10 IfElseStatement
;;;                     { 10 do while Statement
L9_loop_16:
;;;                       { 11 CompoundStatement
;;;                         { 12 List
;;;                           { 13 IfElseStatement
;;;                             { 14 Expr l && r
;;;                               { 15 TypeName (internal)
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = int (80000)
;;;                                 } 16 TypeSpecifier (all)
;;;                               } 15 TypeName (internal)
;;;                               { 15 IfElseStatement
;;;                                 { 16 Expr ! r
;;;                                   { 17 Expr --r
;;;                                     { 18 Expr * r
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                       } 19 Expression (variable name)
;;;                                     } 18 Expr * r
;--     + (member)
        ADD     RR, #0x0012
;--     move_rr_to_ll
        MOVE    RR, LL
;--     content
        MOVE    (RR), RR
;--     --
        SUB     RR, #0x0001
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                   } 17 Expr --r
;--     16 bit ! r
        LNOT    RR
;;;                                 } 16 Expr ! r
;--     branch_false
        JMP     RRZ, L9_endif_19
;;;                                 { 16 ExpressionStatement
;;;                                   { 17 Expr l & r
;;;                                     { 18 TypeName (internal)
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = int (80000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                     } 18 TypeName (internal)
;;;                                     { 18 Expr * r
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                       } 19 Expression (variable name)
;;;                                     } 18 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0x0002
;;;                                   } 17 Expr l & r
;;;                                 } 16 ExpressionStatement
L9_endif_19:
;;;                               } 15 IfElseStatement
;;;                             } 14 Expr l && r
;--     branch_false
        JMP     RRZ, L9_endif_18
;;;                             { 14 CompoundStatement
;;;                               { 15 List
;;;                                 { 16 ExpressionStatement
;;;                                   { 17 Expr l & r
;;;                                     { 18 TypeName
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = char (20000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                       { 19 List
;;;                                         { 20 DeclItem
;;;                                           what = DECL_NAME
;;;                                           name = status
;;;                                         } 20 DeclItem
;;;                                       } 19 List
;;;                                     } 18 TypeName
;;;                                     { 18 Expr l & r
;;;                                       { 19 TypeName (internal)
;;;                                         { 20 TypeSpecifier (all)
;;;                                           spec = int (80000)
;;;                                         } 20 TypeSpecifier (all)
;;;                                       } 19 TypeName (internal)
;;;                                       { 19 Expr * r
;;;                                         { 20 Expression (variable name)
;;;                                           expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                         } 20 Expression (variable name)
;;;                                       } 19 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0xFFFD
;;;                                     } 18 Expr l & r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                     { 18 Expr * r
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -7 (16 bit)
        MOVE    5(SP), RR
;;;                                       } 19 Expression (variable name)
;;;                                     } 18 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                   } 17 Expr l & r
;;;                                 } 16 ExpressionStatement
;;;                                 { 16 IfElseStatement
;;;                                   { 17 Expr l & r
;;;                                     { 18 TypeName (internal)
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = int (80000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                     } 18 TypeName (internal)
;;;                                     { 18 Expr * r
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                       } 19 Expression (variable name)
;;;                                     } 18 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0x0001
;;;                                   } 17 Expr l & r
;--     branch_false
        JMP     RRZ, L9_endif_20
;;;                                   { 17 CompoundStatement
;;;                                     { 18 List
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l & r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = status
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr l & r
;;;                                             { 22 TypeName (internal)
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                             } 22 TypeName (internal)
;;;                                             { 22 Expr * r
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                               } 23 Expression (variable name)
;;;                                             } 22 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0xFFFE
;;;                                           } 21 Expr l & r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                           { 21 Expr * r
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -7 (16 bit)
        MOVE    5(SP), RR
;;;                                             } 22 Expression (variable name)
;;;                                           } 21 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                         } 20 Expr l & r
;;;                                       } 19 ExpressionStatement
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = sema_ret
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0xFFFF, RR
;;;                                           } 21 NumericExpression (constant 1 = 0x1)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                           { 21 Expr * r
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -7 (16 bit)
        MOVE    5(SP), RR
;;;                                             } 22 Expression (variable name)
;;;                                           } 21 Expr * r
;--     + (member)
        ADD     RR, #0x000C
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (struct/union)
;;;                                               spec = struct '_semaphore' (800000)
;;;                                               name = _semaphore
;;;                                             } 22 TypeSpecifier (struct/union)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_POINTER
;;;                                                 { 24 List
;;;                                                   { 25 Ptr
;;;                                                   } 25 Ptr
;;;                                                 } 24 List
;;;                                               } 23 DeclItem
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = s
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr * r
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                             } 22 Expression (variable name)
;;;                                           } 21 Expr * r
;--     + (member)
        ADD     RR, #0x000E
;--     content
        MOVE    (RR), RR
;--     store_rr_var s = -4(FP), SP at -6
        MOVE    RR, 2(SP)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr ++r
;;;                                           { 21 Expr * r
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -6 (16 bit)
        MOVE    2(SP), RR
;;;                                             } 22 Expression (variable name)
;;;                                           } 21 Expr * r
;--     + (member)
;--     move_rr_to_ll
        MOVE    RR, LL
;--     content
        MOVE    (RR), RR
;--     ++
        ADD     RR, #0x0001
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                         } 20 Expr ++r
;;;                                       } 19 ExpressionStatement
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (struct/union)
;;;                                               spec = struct '_task' (800000)
;;;                                               name = _task
;;;                                             } 22 TypeSpecifier (struct/union)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_POINTER
;;;                                                 { 24 List
;;;                                                   { 25 Ptr
;;;                                                   } 25 Ptr
;;;                                                 } 24 List
;;;                                               } 23 DeclItem
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = ts
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr * r
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -6 (16 bit)
        MOVE    2(SP), RR
;;;                                             } 22 Expression (variable name)
;;;                                           } 21 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     store_rr_var ts = -6(FP), SP at -6
        MOVE    RR, 0(SP)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
;;;                                       { 19 IfElseStatement
;;;                                         { 20 Expr l == r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (struct/union)
;;;                                               spec = struct '_task' (800000)
;;;                                               name = _task
;;;                                             } 22 TypeSpecifier (struct/union)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_POINTER
;;;                                                 { 24 List
;;;                                                   { 25 Ptr
;;;                                                   } 25 Ptr
;;;                                                 } 24 List
;;;                                               } 23 DeclItem
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = t
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                           } 21 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (ts)
;--     load_rr_var ts = -6(FP), SP at -6 (16 bit)
        MOVE    0(SP), RR
;;;                                           } 21 Expression (variable name)
;--     l == r
        SEQ     LL, RR
;;;                                         } 20 Expr l == r
;--     branch_false
        JMP     RRZ, L9_else_21
;;;                                         { 20 CompoundStatement
;;;                                           { 21 List
;;;                                             { 22 IfElseStatement
;;;                                               { 23 Expr l == r
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (struct/union)
;;;                                                     spec = struct '_task' (800000)
;;;                                                     name = _task
;;;                                                   } 25 TypeSpecifier (struct/union)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_POINTER
;;;                                                       { 27 List
;;;                                                         { 28 Ptr
;;;                                                         } 28 Ptr
;;;                                                       } 27 List
;;;                                                     } 26 DeclItem
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = t
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 Expr * r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -6 (16 bit)
        MOVE    2(SP), RR
;;;                                                   } 25 Expression (variable name)
;;;                                                 } 24 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RR
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (t)
;--     load_ll_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), LL
;;;                                                 } 24 Expression (variable name)
;--     l == r
        SEQ     LL, RR
;;;                                               } 23 Expr l == r
;--     branch_false
        JMP     RRZ, L9_else_22
;;;                                               { 23 CompoundStatement
;;;                                                 { 24 List
;;;                                                   { 25 ExpressionStatement
;;;                                                     { 26 Expr l = r
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (struct/union)
;;;                                                           spec = struct '_task' (800000)
;;;                                                           name = _task
;;;                                                         } 28 TypeSpecifier (struct/union)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_POINTER
;;;                                                             { 30 List
;;;                                                               { 31 Ptr
;;;                                                               } 31 Ptr
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = next_waiting
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                       { 27 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                       } 27 NumericExpression (constant 0 = 0x0)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                       { 27 Expr * r
;;;                                                         { 28 Expression (variable name)
;;;                                                           expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -8 (16 bit)
        MOVE    4(SP), RR
;;;                                                         } 28 Expression (variable name)
;;;                                                       } 27 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                     } 26 Expr l = r
;;;                                                   } 25 ExpressionStatement
;;;                                                   { 25 ExpressionStatement
;;;                                                     { 26 Expr l = r
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (struct/union)
;;;                                                           spec = struct '_task' (800000)
;;;                                                           name = _task
;;;                                                         } 28 TypeSpecifier (struct/union)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_POINTER
;;;                                                             { 30 List
;;;                                                               { 31 Ptr
;;;                                                               } 31 Ptr
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = last_waiting
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                       { 27 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                       } 27 NumericExpression (constant 0 = 0x0)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                       { 27 Expr * r
;;;                                                         { 28 Expression (variable name)
;;;                                                           expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -8 (16 bit)
        MOVE    4(SP), RR
;;;                                                         } 28 Expression (variable name)
;;;                                                       } 27 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                     } 26 Expr l = r
;;;                                                   } 25 ExpressionStatement
;;;                                                 } 24 List
;--     pop 0 bytes
;;;                                               } 23 CompoundStatement
;--     branch
        JMP     L9_endif_22
L9_else_22:
;;;                                               { 23 CompoundStatement
;;;                                                 { 24 List
;;;                                                   { 25 ExpressionStatement
;;;                                                     { 26 Expr l = r
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (struct/union)
;;;                                                           spec = struct '_task' (800000)
;;;                                                           name = _task
;;;                                                         } 28 TypeSpecifier (struct/union)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_POINTER
;;;                                                             { 30 List
;;;                                                               { 31 Ptr
;;;                                                               } 31 Ptr
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = next_waiting
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                       { 27 Expr * r
;;;                                                         { 28 Expression (variable name)
;;;                                                           expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                                         } 28 Expression (variable name)
;;;                                                       } 27 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                       { 27 Expr * r
;;;                                                         { 28 Expression (variable name)
;;;                                                           expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -8 (16 bit)
        MOVE    4(SP), RR
;;;                                                         } 28 Expression (variable name)
;;;                                                       } 27 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                     } 26 Expr l = r
;;;                                                   } 25 ExpressionStatement
;;;                                                 } 24 List
;--     pop 0 bytes
;;;                                               } 23 CompoundStatement
L9_endif_22:
;;;                                             } 22 IfElseStatement
;;;                                           } 21 List
;--     pop 0 bytes
;;;                                         } 20 CompoundStatement
;--     branch
        JMP     L9_endif_21
L9_else_21:
;;;                                         { 20 CompoundStatement
;;;                                           { 21 List
;;;                                             { 22 while Statement
;--     branch
        JMP     L9_cont_23
L9_loop_23:
;;;                                               { 23 ExpressionStatement
;;;                                                 { 24 Expr l = r
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (struct/union)
;;;                                                       spec = struct '_task' (800000)
;;;                                                       name = _task
;;;                                                     } 26 TypeSpecifier (struct/union)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_POINTER
;;;                                                         { 28 List
;;;                                                           { 29 Ptr
;;;                                                           } 29 Ptr
;;;                                                         } 28 List
;;;                                                       } 27 DeclItem
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = ts
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                   { 25 Expr * r
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (ts)
;--     load_rr_var ts = -6(FP), SP at -6 (16 bit)
        MOVE    0(SP), RR
;;;                                                     } 26 Expression (variable name)
;;;                                                   } 25 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;--     store_rr_var ts = -6(FP), SP at -6
        MOVE    RR, 0(SP)
;;;                                                 } 24 Expr l = r
;;;                                               } 23 ExpressionStatement
L9_cont_23:
;;;                                               { 23 Expr l != r
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (struct/union)
;;;                                                     spec = struct '_task' (800000)
;;;                                                     name = _task
;;;                                                   } 25 TypeSpecifier (struct/union)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_POINTER
;;;                                                       { 27 List
;;;                                                         { 28 Ptr
;;;                                                         } 28 Ptr
;;;                                                       } 27 List
;;;                                                     } 26 DeclItem
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = t
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 Expr * r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (ts)
;--     load_rr_var ts = -6(FP), SP at -6 (16 bit)
        MOVE    0(SP), RR
;;;                                                   } 25 Expression (variable name)
;;;                                                 } 24 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (t)
;--     load_ll_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), LL
;;;                                                 } 24 Expression (variable name)
;--     l != r
        SNE     LL, RR
;;;                                               } 23 Expr l != r
;--     branch_true
        JMP     RRNZ, L9_loop_23
L9_brk_24:
;;;                                             } 22 while Statement
;;;                                             { 22 ExpressionStatement
;;;                                               { 23 Expr l = r
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (struct/union)
;;;                                                     spec = struct '_task' (800000)
;;;                                                     name = _task
;;;                                                   } 25 TypeSpecifier (struct/union)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_POINTER
;;;                                                       { 27 List
;;;                                                         { 28 Ptr
;;;                                                         } 28 Ptr
;;;                                                       } 27 List
;;;                                                     } 26 DeclItem
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = next_waiting_task
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 Expr * r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                                   } 25 Expression (variable name)
;;;                                                 } 24 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                 { 24 Expr * r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (ts)
;--     load_rr_var ts = -6(FP), SP at -8 (16 bit)
        MOVE    2(SP), RR
;;;                                                   } 25 Expression (variable name)
;;;                                                 } 24 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                               } 23 Expr l = r
;;;                                             } 22 ExpressionStatement
;;;                                             { 22 IfElseStatement
;;;                                               { 23 Expr l == r
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (struct/union)
;;;                                                     spec = struct '_task' (800000)
;;;                                                     name = _task
;;;                                                   } 25 TypeSpecifier (struct/union)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_POINTER
;;;                                                       { 27 List
;;;                                                         { 28 Ptr
;;;                                                         } 28 Ptr
;;;                                                       } 27 List
;;;                                                     } 26 DeclItem
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = t
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 Expr * r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -6 (16 bit)
        MOVE    2(SP), RR
;;;                                                   } 25 Expression (variable name)
;;;                                                 } 24 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RR
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (t)
;--     load_ll_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), LL
;;;                                                 } 24 Expression (variable name)
;--     l == r
        SEQ     LL, RR
;;;                                               } 23 Expr l == r
;--     branch_false
        JMP     RRZ, L9_endif_25
;;;                                               { 23 ExpressionStatement
;;;                                                 { 24 Expr l = r
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (struct/union)
;;;                                                       spec = struct '_task' (800000)
;;;                                                       name = _task
;;;                                                     } 26 TypeSpecifier (struct/union)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_POINTER
;;;                                                         { 28 List
;;;                                                           { 29 Ptr
;;;                                                           } 29 Ptr
;;;                                                         } 28 List
;;;                                                       } 27 DeclItem
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = last_waiting
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (ts)
;--     load_rr_var ts = -6(FP), SP at -6 (16 bit)
        MOVE    0(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                   { 25 Expr * r
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (s)
;--     load_rr_var s = -4(FP), SP at -8 (16 bit)
        MOVE    4(SP), RR
;;;                                                     } 26 Expression (variable name)
;;;                                                   } 25 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                 } 24 Expr l = r
;;;                                               } 23 ExpressionStatement
L9_endif_25:
;;;                                             } 22 IfElseStatement
;;;                                           } 21 List
;--     pop 0 bytes
;;;                                         } 20 CompoundStatement
L9_endif_21:
;;;                                       } 19 IfElseStatement
;;;                                     } 18 List
;--     pop 0 bytes
;;;                                   } 17 CompoundStatement
L9_endif_20:
;;;                                 } 16 IfElseStatement
;;;                               } 15 List
;--     pop 0 bytes
;;;                             } 14 CompoundStatement
L9_endif_18:
;;;                           } 13 IfElseStatement
;;;                         } 12 List
;--     pop 0 bytes
;;;                       } 11 CompoundStatement
L9_cont_16:
;;;                       { 11 Expr l != r
;;;                         { 12 TypeName
;;;                           { 13 TypeSpecifier (struct/union)
;;;                             spec = struct '_task' (800000)
;;;                             name = _task
;;;                           } 13 TypeSpecifier (struct/union)
;;;                           { 13 List
;;;                             { 14 DeclItem
;;;                               what = DECL_POINTER
;;;                               { 15 List
;;;                                 { 16 Ptr
;;;                                 } 16 Ptr
;;;                               } 15 List
;;;                             } 14 DeclItem
;;;                             { 14 DeclItem
;;;                               what = DECL_NAME
;;;                               name = current_task
;;;                             } 14 DeclItem
;;;                           } 13 List
;;;                         } 12 TypeName
;;;                         { 12 Expr l = r
;;;                           { 13 TypeName
;;;                             { 14 TypeSpecifier (struct/union)
;;;                               spec = struct '_task' (800000)
;;;                               name = _task
;;;                             } 14 TypeSpecifier (struct/union)
;;;                             { 14 List
;;;                               { 15 DeclItem
;;;                                 what = DECL_POINTER
;;;                                 { 16 List
;;;                                   { 17 Ptr
;;;                                   } 17 Ptr
;;;                                 } 16 List
;;;                               } 15 DeclItem
;;;                               { 15 DeclItem
;;;                                 what = DECL_NAME
;;;                                 name = t
;;;                               } 15 DeclItem
;;;                             } 14 List
;;;                           } 13 TypeName
;;;                           { 13 Expr * r
;;;                             { 14 Expression (variable name)
;;;                               expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                             } 14 Expression (variable name)
;;;                           } 13 Expr * r
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     store_rr_var t = -2(FP), SP at -6
        MOVE    RR, 4(SP)
;;;                         } 12 Expr l = r
;;;                         { 12 Expression (variable name)
;;;                           expr_type = "identifier" (current_task)
;--     load_ll_var current_task, (16 bit)
        MOVE    (Ccurrent_task), LL
;;;                         } 12 Expression (variable name)
;--     l != r
        SNE     LL, RR
;;;                       } 11 Expr l != r
;--     branch_true
        JMP     RRNZ, L9_loop_16
L9_brk_17:
;;;                     } 10 do while Statement
;;;                   } 9 List
;--     pop 6 bytes
        ADD     SP, #6
;;;                 } 8 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                 { 8 FunctionDefinition
;;;                   { 9 TypeName
;;;                     { 10 TypeSpecifier (all)
;;;                       spec = void (10000)
;;;                     } 10 TypeSpecifier (all)
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = interrupt
;;;                       } 11 DeclItem
;;;                     } 10 List
;;;                   } 9 TypeName
;;;                   { 9 List
;;;                     { 10 DeclItem
;;;                       what = DECL_NAME
;;;                       name = interrupt
;;;                     } 10 DeclItem
;;;                     { 10 DeclItem
;;;                       what = DECL_FUN
;;;                     } 10 DeclItem
;;;                   } 9 List
Cinterrupt:
;;;                   { 9 CompoundStatement
;;;                     { 10 InitDeclarator
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = ts_1
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                       { 11 Initializer (skalar)
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                       } 11 Initializer (skalar)
;;;                     } 10 InitDeclarator
;;;                     { 10 InitDeclarator
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = ts_2
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                       { 11 Initializer (skalar)
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                       } 11 Initializer (skalar)
;;;                     } 10 InitDeclarator
;;;                     { 10 List
;;;                       { 11 ExpressionStatement
        MOVE RR, -(SP)
;;;                       } 11 ExpressionStatement
;;;                       { 11 ExpressionStatement
        MOVE LL, RR
;;;                       } 11 ExpressionStatement
;;;                       { 11 ExpressionStatement
        MOVE RR, -(SP)
;;;                       } 11 ExpressionStatement
;;;                       { 11 IfElseStatement
;;;                         { 12 Expr l & r
;;;                           { 13 TypeName (internal)
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = int (80000)
;;;                             } 14 TypeSpecifier (all)
;;;                           } 13 TypeName (internal)
        IN   (IN_STATUS), RU
;--     l & r
        AND     RR, #0x0010
;;;                         } 12 Expr l & r
;--     branch_false
        JMP     RRZ, L10_endif_26
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l = r
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = char (20000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = ts_1
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 Expr l(r)
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = char (20000)
;;;                                 } 16 TypeSpecifier (all)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = rx_interrupt
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;--     push 1 bytes
;--     call
        CALL    Crx_interrupt
;--     pop 0 bytes
;;;                             } 14 Expr l(r)
;--     store_rr_var ts_1 = -1(FP), SP at -6
        MOVE    R, 5(SP)
;;;                           } 13 Expr l = r
;;;                         } 12 ExpressionStatement
L10_endif_26:
;;;                       } 11 IfElseStatement
;;;                       { 11 IfElseStatement
;;;                         { 12 Expr l & r
;;;                           { 13 TypeName (internal)
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = int (80000)
;;;                             } 14 TypeSpecifier (all)
;;;                           } 13 TypeName (internal)
        IN   (IN_STATUS), RU
;--     l & r
        AND     RR, #0x0020
;;;                         } 12 Expr l & r
;--     branch_false
        JMP     RRZ, L10_endif_27
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l = r
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = char (20000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = ts_2
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 Expr l(r)
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = char (20000)
;;;                                 } 16 TypeSpecifier (all)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = tx_interrupt
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;--     push 1 bytes
;--     call
        CALL    Ctx_interrupt
;--     pop 0 bytes
;;;                             } 14 Expr l(r)
;--     store_rr_var ts_2 = -2(FP), SP at -6
        MOVE    R, 4(SP)
;;;                           } 13 Expr l = r
;;;                         } 12 ExpressionStatement
L10_endif_27:
;;;                       } 11 IfElseStatement
;;;                       { 11 IfElseStatement
;;;                         { 12 Expr l & r
;;;                           { 13 TypeName (internal)
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = int (80000)
;;;                             } 14 TypeSpecifier (all)
;;;                           } 13 TypeName (internal)
        IN   (IN_STATUS), RU
;--     l & r
        AND     RR, #0x0040
;;;                         } 12 Expr l & r
;--     branch_false
        JMP     RRZ, L10_endif_28
;;;                         { 12 CompoundStatement
;;;                           { 13 List
;;;                             { 14 ExpressionStatement
;;;                               { 15 Expr l(r)
;;;                                 { 16 TypeName
;;;                                   { 17 TypeSpecifier (all)
;;;                                     spec = void (10000)
;;;                                   } 17 TypeSpecifier (all)
;;;                                   { 17 List
;;;                                     { 18 DeclItem
;;;                                       what = DECL_NAME
;;;                                       name = timer_interrupt
;;;                                     } 18 DeclItem
;;;                                   } 17 List
;;;                                 } 16 TypeName
;--     push 0 bytes
;--     call
        CALL    Ctimer_interrupt
;--     pop 0 bytes
;;;                               } 15 Expr l(r)
;;;                             } 14 ExpressionStatement
;;;                             { 14 ExpressionStatement
;;;                               { 15 Expr l = r
;;;                                 { 16 TypeName
;;;                                   { 17 TypeSpecifier (all)
;;;                                     spec = char (20000)
;;;                                   } 17 TypeSpecifier (all)
;;;                                   { 17 List
;;;                                     { 18 DeclItem
;;;                                       what = DECL_NAME
;;;                                       name = ts_1
;;;                                     } 18 DeclItem
;;;                                   } 17 List
;;;                                 } 16 TypeName
;;;                                 { 16 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0xFFFF, RR
;;;                                 } 16 NumericExpression (constant 1 = 0x1)
;--     store_rr_var ts_1 = -1(FP), SP at -6
        MOVE    R, 5(SP)
;;;                               } 15 Expr l = r
;;;                             } 14 ExpressionStatement
;;;                           } 13 List
;--     pop 0 bytes
;;;                         } 12 CompoundStatement
L10_endif_28:
;;;                       } 11 IfElseStatement
;;;                       { 11 IfElseStatement
;;;                         { 12 Expr l | r
;;;                           { 13 TypeName (internal)
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = int (80000)
;;;                             } 14 TypeSpecifier (all)
;;;                           } 13 TypeName (internal)
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (ts_1)
;--     load_rr_var ts_1 = -1(FP), SP at -6 (8 bit)
        MOVE    5(SP), RS
;;;                           } 13 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                           { 13 Expression (variable name)
;;;                             expr_type = "identifier" (ts_2)
;--     load_rr_var ts_2 = -2(FP), SP at -6 (8 bit)
        MOVE    4(SP), RS
;;;                           } 13 Expression (variable name)
;--     l | r
        OR      LL, RR
;;;                         } 12 Expr l | r
;--     branch_false
        JMP     RRZ, L10_endif_29
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l(r)
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = void (10000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = switch_tasks
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;--     push 0 bytes
;--     call
        CALL    Cswitch_tasks
;--     pop 0 bytes
;;;                           } 13 Expr l(r)
;;;                         } 12 ExpressionStatement
L10_endif_29:
;;;                       } 11 IfElseStatement
;;;                       { 11 ExpressionStatement
        MOVE (SP)+, RR
;;;                       } 11 ExpressionStatement
;;;                       { 11 ExpressionStatement
        MOVE RR, LL
;;;                       } 11 ExpressionStatement
;;;                       { 11 ExpressionStatement
        MOVE (SP)+, RR
;;;                       } 11 ExpressionStatement
;;;                       { 11 ExpressionStatement
        ADD  SP, #2
;;;                       } 11 ExpressionStatement
;;;                       { 11 ExpressionStatement
        RETI
;;;                       } 11 ExpressionStatement
;;;                     } 10 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                   } 9 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                   { 9 FunctionDefinition
;;;                     { 10 TypeName
;;;                       { 11 TypeSpecifier (all)
;;;                         spec = void (10000)
;;;                       } 11 TypeSpecifier (all)
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = sleep
;;;                         } 12 DeclItem
;;;                       } 11 List
;;;                     } 10 TypeName
;;;                     { 10 List
;;;                       { 11 DeclItem
;;;                         what = DECL_NAME
;;;                         name = sleep
;;;                       } 11 DeclItem
;;;                       { 11 DeclItem
;;;                         what = DECL_FUN
;;;                         { 12 List
;;;                           { 13 ParameterDeclaration
;;;                             isEllipsis = false
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = int (80000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = millisecs
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                           } 13 ParameterDeclaration
;;;                         } 12 List
;;;                       } 11 DeclItem
;;;                     } 10 List
Csleep:
;;;                     { 10 CompoundStatement
;;;                       { 11 List
;;;                         { 12 ExpressionStatement
        DI
;;;                         } 12 ExpressionStatement
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l = r
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = int (80000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = sleep_count
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 Expression (variable name)
;;;                               expr_type = "identifier" (millisecs)
;--     load_rr_var millisecs = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                             } 14 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                             { 14 Expr * r
;;;                               { 15 Expression (variable name)
;;;                                 expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                               } 15 Expression (variable name)
;;;                             } 14 Expr * r
;--     + (member)
        ADD     RR, #0x0012
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                           } 13 Expr l = r
;;;                         } 12 ExpressionStatement
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l = r
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = char (20000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = status
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 NumericExpression (constant 2 = 0x2)
;--     load_rr_constant
        MOVE    #0x0002, RR
;;;                             } 14 NumericExpression (constant 2 = 0x2)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                             { 14 Expr * r
;;;                               { 15 Expression (variable name)
;;;                                 expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                               } 15 Expression (variable name)
;;;                             } 14 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                           } 13 Expr l = r
;;;                         } 12 ExpressionStatement
;;;                         { 12 ExpressionStatement
;;;                           { 13 Expr l(r)
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = void (10000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = switch_tasks
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;--     push 0 bytes
;--     call
        CALL    Cswitch_tasks
;--     pop 0 bytes
;;;                           } 13 Expr l(r)
;;;                         } 12 ExpressionStatement
;;;                         { 12 ExpressionStatement
        RETI
;;;                         } 12 ExpressionStatement
;;;                       } 11 List
;--     pop 0 bytes
;;;                     } 10 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                     { 10 FunctionDefinition
;;;                       { 11 TypeName
;;;                         { 12 TypeSpecifier (all)
;;;                           spec = void (10000)
;;;                         } 12 TypeSpecifier (all)
;;;                         { 12 List
;;;                           { 13 DeclItem
;;;                             what = DECL_NAME
;;;                             name = deschedule
;;;                           } 13 DeclItem
;;;                         } 12 List
;;;                       } 11 TypeName
;;;                       { 11 List
;;;                         { 12 DeclItem
;;;                           what = DECL_NAME
;;;                           name = deschedule
;;;                         } 12 DeclItem
;;;                         { 12 DeclItem
;;;                           what = DECL_FUN
;;;                         } 12 DeclItem
;;;                       } 11 List
Cdeschedule:
;;;                       { 11 CompoundStatement
;;;                         { 12 List
;;;                           { 13 ExpressionStatement
        DI
;;;                           } 13 ExpressionStatement
;;;                           { 13 ExpressionStatement
;;;                             { 14 Expr l(r)
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = void (10000)
;;;                                 } 16 TypeSpecifier (all)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = switch_tasks
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;--     push 0 bytes
;--     call
        CALL    Cswitch_tasks
;--     pop 0 bytes
;;;                             } 14 Expr l(r)
;;;                           } 13 ExpressionStatement
;;;                           { 13 ExpressionStatement
        RETI
;;;                           } 13 ExpressionStatement
;;;                         } 12 List
;--     pop 0 bytes
;;;                       } 11 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                       { 11 FunctionDefinition
;;;                         { 12 TypeName
;;;                           { 13 TypeSpecifier (all)
;;;                             spec = int (80000)
;;;                           } 13 TypeSpecifier (all)
;;;                           { 13 List
;;;                             { 14 DeclItem
;;;                               what = DECL_NAME
;;;                               name = strlen
;;;                             } 14 DeclItem
;;;                           } 13 List
;;;                         } 12 TypeName
;;;                         { 12 List
;;;                           { 13 DeclItem
;;;                             what = DECL_NAME
;;;                             name = strlen
;;;                           } 13 DeclItem
;;;                           { 13 DeclItem
;;;                             what = DECL_FUN
;;;                             { 14 List
;;;                               { 15 ParameterDeclaration
;;;                                 isEllipsis = false
;;;                                 { 16 TypeName
;;;                                   { 17 TypeSpecifier (all)
;;;                                     spec = const char (20100)
;;;                                   } 17 TypeSpecifier (all)
;;;                                   { 17 List
;;;                                     { 18 DeclItem
;;;                                       what = DECL_POINTER
;;;                                       { 19 List
;;;                                         { 20 Ptr
;;;                                         } 20 Ptr
;;;                                       } 19 List
;;;                                     } 18 DeclItem
;;;                                     { 18 DeclItem
;;;                                       what = DECL_NAME
;;;                                       name = buffer
;;;                                     } 18 DeclItem
;;;                                   } 17 List
;;;                                 } 16 TypeName
;;;                               } 15 ParameterDeclaration
;;;                             } 14 List
;;;                           } 13 DeclItem
;;;                         } 12 List
Cstrlen:
;;;                         { 12 CompoundStatement
;;;                           { 13 InitDeclarator
;;;                             { 14 List
;;;                               { 15 DeclItem
;;;                                 what = DECL_POINTER
;;;                                 { 16 List
;;;                                   { 17 Ptr
;;;                                   } 17 Ptr
;;;                                 } 16 List
;;;                               } 15 DeclItem
;;;                               { 15 DeclItem
;;;                                 what = DECL_NAME
;;;                                 name = from
;;;                               } 15 DeclItem
;;;                             } 14 List
;;;                             { 14 Initializer (skalar)
;;;                               { 15 Expression (variable name)
;;;                                 expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                               } 15 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                             } 14 Initializer (skalar)
;;;                           } 13 InitDeclarator
;;;                           { 13 List
;;;                             { 14 while Statement
;--     branch
        JMP     L13_cont_30
L13_loop_30:
;;;                               { 15 ExpressionStatement
;;;                                 { 16 Expr l - r
;;;                                   { 17 Expr ++r
;;;                                     { 18 Expression (variable name)
;;;                                       expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                     } 18 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var buffer = 2(FP), SP at -2
        MOVE    RR, 4(SP)
;;;                                   } 17 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                 } 16 Expr l - r
;;;                               } 15 ExpressionStatement
L13_cont_30:
;;;                               { 15 Expr * r
;;;                                 { 16 Expression (variable name)
;;;                                   expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                 } 16 Expression (variable name)
;--     content
        MOVE    (RR), RS
;;;                               } 15 Expr * r
;--     branch_true
        JMP     RRNZ, L13_loop_30
L13_brk_31:
;;;                             } 14 while Statement
;;;                             { 14 return Statement
;;;                               { 15 Expr l - r
;;;                                 { 16 Expression (variable name)
;;;                                   expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                 } 16 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                 { 16 Expression (variable name)
;;;                                   expr_type = "identifier" (from)
;--     load_rr_var from = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                 } 16 Expression (variable name)
;--     scale_rr *1
;--     l - r
        SUB     LL, RR
;--     scale *1
;;;                               } 15 Expr l - r
;--     ret
        ADD     SP, #2
        RET
;;;                             } 14 return Statement
;;;                           } 13 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                         } 12 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                         { 12 FunctionDefinition
;;;                           { 13 TypeName
;;;                             { 14 TypeSpecifier (all)
;;;                               spec = int (80000)
;;;                             } 14 TypeSpecifier (all)
;;;                             { 14 List
;;;                               { 15 DeclItem
;;;                                 what = DECL_NAME
;;;                                 name = putchr
;;;                               } 15 DeclItem
;;;                             } 14 List
;;;                           } 13 TypeName
;;;                           { 13 List
;;;                             { 14 DeclItem
;;;                               what = DECL_NAME
;;;                               name = putchr
;;;                             } 14 DeclItem
;;;                             { 14 DeclItem
;;;                               what = DECL_FUN
;;;                               { 15 List
;;;                                 { 16 ParameterDeclaration
;;;                                   isEllipsis = false
;;;                                   { 17 TypeName
;;;                                     { 18 TypeSpecifier (all)
;;;                                       spec = char (20000)
;;;                                     } 18 TypeSpecifier (all)
;;;                                     { 18 List
;;;                                       { 19 DeclItem
;;;                                         what = DECL_NAME
;;;                                         name = c
;;;                                       } 19 DeclItem
;;;                                     } 18 List
;;;                                   } 17 TypeName
;;;                                 } 16 ParameterDeclaration
;;;                               } 15 List
;;;                             } 14 DeclItem
;;;                           } 13 List
Cputchr:
;;;                           { 13 CompoundStatement
;;;                             { 14 List
;;;                               { 15 ExpressionStatement
;;;                                 { 16 Expr l(r)
;;;                                   { 17 TypeName
;;;                                     { 18 TypeSpecifier (all)
;;;                                       spec = void (10000)
;;;                                     } 18 TypeSpecifier (all)
;;;                                     { 18 List
;;;                                       { 19 DeclItem
;;;                                         what = DECL_NAME
;;;                                         name = P
;;;                                       } 19 DeclItem
;;;                                     } 18 List
;;;                                   } 17 TypeName
;;;                                   { 17 ParameterDeclaration
;;;                                     isEllipsis = false
;;;                                     { 18 TypeName
;;;                                       { 19 TypeSpecifier (struct/union)
;;;                                         spec = struct '_semaphore' (800000)
;;;                                         name = _semaphore
;;;                                       } 19 TypeSpecifier (struct/union)
;;;                                       { 19 List
;;;                                         { 20 DeclItem
;;;                                           what = DECL_POINTER
;;;                                           { 21 List
;;;                                             { 22 Ptr
;;;                                             } 22 Ptr
;;;                                           } 21 List
;;;                                         } 20 DeclItem
;;;                                         { 20 DeclItem
;;;                                           what = DECL_NAME
;;;                                           name = sema
;;;                                         } 20 DeclItem
;;;                                       } 19 List
;;;                                     } 18 TypeName
;;;                                   } 17 ParameterDeclaration
;;;                                   { 17 Expr & r
;--     load_address tx_sema
        MOVE    #Ctx_sema, RR
;;;                                   } 17 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                 } 16 Expr l(r)
;;;                               } 15 ExpressionStatement
;;;                               { 15 ExpressionStatement
;;;                                 { 16 Expr l = r
;;;                                   { 17 TypeName
;;;                                     { 18 TypeSpecifier (all)
;;;                                       spec = unsigned char (22000)
;;;                                     } 18 TypeSpecifier (all)
;;;                                     { 18 List
;;;                                       { 19 DeclItem
;;;                                         what = DECL_NAME
;;;                                         name = serial_out_buffer
;;;                                       } 19 DeclItem
;;;                                     } 18 List
;;;                                   } 17 TypeName
;;;                                   { 17 Expression (variable name)
;;;                                     expr_type = "identifier" (c)
;--     load_rr_var c = 2(FP), SP at 0 (8 bit)
        MOVE    2(SP), RS
;;;                                   } 17 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                   { 17 Expr l[r]
;;;                                     { 18 Expression (variable name)
;;;                                       expr_type = "identifier" (serial_out_put)
;--     load_rr_var serial_out_put, (8 bit)
        MOVE    (Cserial_out_put), RU
;;;                                     } 18 Expression (variable name)
;--     scale_rr *1
;--     add_address serial_out_buffer
        ADD     RR, #Cserial_out_buffer
;;;                                   } 17 Expr l[r]
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RU
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                 } 16 Expr l = r
;;;                               } 15 ExpressionStatement
;;;                               { 15 IfElseStatement
;;;                                 { 16 Expr l >= r
;;;                                   { 17 TypeName (internal)
;;;                                     { 18 TypeSpecifier (all)
;;;                                       spec = unsigned int (82000)
;;;                                     } 18 TypeSpecifier (all)
;;;                                   } 17 TypeName (internal)
;;;                                   { 17 Expr ++r
;;;                                     { 18 Expression (variable name)
;;;                                       expr_type = "identifier" (serial_out_put)
;--     load_rr_var serial_out_put, (8 bit)
        MOVE    (Cserial_out_put), RU
;;;                                     } 18 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var serial_out_put
        MOVE    R, (Cserial_out_put)
;;;                                   } 17 Expr ++r
;--     l >= r
        SHS     RR, #0x0010
;;;                                 } 16 Expr l >= r
;--     branch_false
        JMP     RRZ, L14_endif_32
;;;                                 { 16 ExpressionStatement
;;;                                   { 17 Expr l = r
;;;                                     { 18 TypeName
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = unsigned char (22000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                       { 19 List
;;;                                         { 20 DeclItem
;;;                                           what = DECL_NAME
;;;                                           name = serial_out_put
;;;                                         } 20 DeclItem
;;;                                       } 19 List
;;;                                     } 18 TypeName
;;;                                     { 18 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                     } 18 NumericExpression (constant 0 = 0x0)
;--     store_rr_var serial_out_put
        MOVE    R, (Cserial_out_put)
;;;                                   } 17 Expr l = r
;;;                                 } 16 ExpressionStatement
L14_endif_32:
;;;                               } 15 IfElseStatement
;;;                               { 15 ExpressionStatement
        MOVE #0x07, RR
;;;                               } 15 ExpressionStatement
;;;                               { 15 ExpressionStatement
        OUT  R, (OUT_INT_MASK)
;;;                               } 15 ExpressionStatement
;;;                               { 15 ExpressionStatement
;;;                                 { 16 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                 } 16 NumericExpression (constant 1 = 0x1)
;;;                               } 15 ExpressionStatement
;;;                             } 14 List
;--     pop 0 bytes
;;;                           } 13 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                           { 13 FunctionDefinition
;;;                             { 14 TypeName
;;;                               { 15 TypeSpecifier (all)
;;;                                 spec = void (10000)
;;;                               } 15 TypeSpecifier (all)
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = print_n
;;;                                 } 16 DeclItem
;;;                               } 15 List
;;;                             } 14 TypeName
;;;                             { 14 List
;;;                               { 15 DeclItem
;;;                                 what = DECL_NAME
;;;                                 name = print_n
;;;                               } 15 DeclItem
;;;                               { 15 DeclItem
;;;                                 what = DECL_FUN
;;;                                 { 16 List
;;;                                   { 17 ParameterDeclaration
;;;                                     isEllipsis = false
;;;                                     { 18 TypeName
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = char (20000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                       { 19 List
;;;                                         { 20 DeclItem
;;;                                           what = DECL_NAME
;;;                                           name = c
;;;                                         } 20 DeclItem
;;;                                       } 19 List
;;;                                     } 18 TypeName
;;;                                   } 17 ParameterDeclaration
;;;                                   { 17 ParameterDeclaration
;;;                                     isEllipsis = false
;;;                                     { 18 TypeName
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = int (80000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                       { 19 List
;;;                                         { 20 DeclItem
;;;                                           what = DECL_NAME
;;;                                           name = count
;;;                                         } 20 DeclItem
;;;                                       } 19 List
;;;                                     } 18 TypeName
;;;                                   } 17 ParameterDeclaration
;;;                                 } 16 List
;;;                               } 15 DeclItem
;;;                             } 14 List
Cprint_n:
;;;                             { 14 CompoundStatement
;;;                               { 15 List
;;;                                 { 16 for Statement
;;;                                   { 17 ExpressionStatement
;;;                                   } 17 ExpressionStatement
;--     branch
        JMP     L15_tst_33
L15_loop_33:
;;;                                   { 17 ExpressionStatement
;;;                                     { 18 Expr l(r)
;;;                                       { 19 TypeName
;;;                                         { 20 TypeSpecifier (all)
;;;                                           spec = int (80000)
;;;                                         } 20 TypeSpecifier (all)
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = putchr
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                       } 19 TypeName
;;;                                       { 19 ParameterDeclaration
;;;                                         isEllipsis = false
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = char (20000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = c
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                       } 19 ParameterDeclaration
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (c)
;--     load_rr_var c = 2(FP), SP at 0 (8 bit)
        MOVE    2(SP), RS
;;;                                       } 19 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                     } 18 Expr l(r)
;;;                                   } 17 ExpressionStatement
L15_cont_33:
;;;                                   { 17 Expr --r
;;;                                     { 18 Expression (variable name)
;;;                                       expr_type = "identifier" (count)
;--     load_rr_var count = 3(FP), SP at 0 (16 bit)
        MOVE    3(SP), RR
;;;                                     } 18 Expression (variable name)
;--     --
        SUB     RR, #0x0001
;--     store_rr_var count = 3(FP), SP at 0
        MOVE    RR, 3(SP)
;;;                                   } 17 Expr --r
L15_tst_33:
;;;                                   { 17 Expr l > r
;;;                                     { 18 TypeName (internal)
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = int (80000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                     } 18 TypeName (internal)
;;;                                     { 18 Expression (variable name)
;;;                                       expr_type = "identifier" (count)
;--     load_rr_var count = 3(FP), SP at 0 (16 bit)
        MOVE    3(SP), RR
;;;                                     } 18 Expression (variable name)
;--     l > r
        SGT     RR, #0x0000
;;;                                   } 17 Expr l > r
;--     branch_true
        JMP     RRNZ, L15_loop_33
L15_brk_34:
;;;                                 } 16 for Statement
;;;                               } 15 List
;--     pop 0 bytes
;;;                             } 14 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                             { 14 FunctionDefinition
;;;                               { 15 TypeName
;;;                                 { 16 TypeSpecifier (all)
;;;                                   spec = void (10000)
;;;                                 } 16 TypeSpecifier (all)
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = print_string
;;;                                   } 17 DeclItem
;;;                                 } 16 List
;;;                               } 15 TypeName
;;;                               { 15 List
;;;                                 { 16 DeclItem
;;;                                   what = DECL_NAME
;;;                                   name = print_string
;;;                                 } 16 DeclItem
;;;                                 { 16 DeclItem
;;;                                   what = DECL_FUN
;;;                                   { 17 List
;;;                                     { 18 ParameterDeclaration
;;;                                       isEllipsis = false
;;;                                       { 19 TypeName
;;;                                         { 20 TypeSpecifier (all)
;;;                                           spec = const char (20100)
;;;                                         } 20 TypeSpecifier (all)
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_POINTER
;;;                                             { 22 List
;;;                                               { 23 Ptr
;;;                                               } 23 Ptr
;;;                                             } 22 List
;;;                                           } 21 DeclItem
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = buffer
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                       } 19 TypeName
;;;                                     } 18 ParameterDeclaration
;;;                                   } 17 List
;;;                                 } 16 DeclItem
;;;                               } 15 List
Cprint_string:
;;;                               { 15 CompoundStatement
;;;                                 { 16 List
;;;                                   { 17 while Statement
;--     branch
        JMP     L16_cont_35
L16_loop_35:
;;;                                     { 18 ExpressionStatement
;;;                                       { 19 Expr l(r)
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = int (80000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = putchr
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                         { 20 ParameterDeclaration
;;;                                           isEllipsis = false
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = c
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                         } 20 ParameterDeclaration
;;;                                         { 20 Expr * r
;;;                                           { 21 Expr l - r
;;;                                             { 22 Expr ++r
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                                               } 23 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var buffer = 2(FP), SP at 0
        MOVE    RR, 2(SP)
;;;                                             } 22 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                           } 21 Expr l - r
;--     content
        MOVE    (RR), RS
;;;                                         } 20 Expr * r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                       } 19 Expr l(r)
;;;                                     } 18 ExpressionStatement
L16_cont_35:
;;;                                     { 18 Expr * r
;;;                                       { 19 Expression (variable name)
;;;                                         expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                                       } 19 Expression (variable name)
;--     content
        MOVE    (RR), RS
;;;                                     } 18 Expr * r
;--     branch_true
        JMP     RRNZ, L16_loop_35
L16_brk_36:
;;;                                   } 17 while Statement
;;;                                 } 16 List
;--     pop 0 bytes
;;;                               } 15 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                               { 15 FunctionDefinition
;;;                                 { 16 TypeName
;;;                                   { 17 TypeSpecifier (all)
;;;                                     spec = void (10000)
;;;                                   } 17 TypeSpecifier (all)
;;;                                   { 17 List
;;;                                     { 18 DeclItem
;;;                                       what = DECL_NAME
;;;                                       name = print_hex
;;;                                     } 18 DeclItem
;;;                                   } 17 List
;;;                                 } 16 TypeName
;;;                                 { 16 List
;;;                                   { 17 DeclItem
;;;                                     what = DECL_NAME
;;;                                     name = print_hex
;;;                                   } 17 DeclItem
;;;                                   { 17 DeclItem
;;;                                     what = DECL_FUN
;;;                                     { 18 List
;;;                                       { 19 ParameterDeclaration
;;;                                         isEllipsis = false
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = char (20000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_POINTER
;;;                                               { 23 List
;;;                                                 { 24 Ptr
;;;                                                 } 24 Ptr
;;;                                               } 23 List
;;;                                             } 22 DeclItem
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = dest
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                       } 19 ParameterDeclaration
;;;                                       { 19 ParameterDeclaration
;;;                                         isEllipsis = false
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = unsigned int (82000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = value
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                       } 19 ParameterDeclaration
;;;                                       { 19 ParameterDeclaration
;;;                                         isEllipsis = false
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = const char (20100)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_POINTER
;;;                                               { 23 List
;;;                                                 { 24 Ptr
;;;                                                 } 24 Ptr
;;;                                               } 23 List
;;;                                             } 22 DeclItem
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = hex
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                       } 19 ParameterDeclaration
;;;                                     } 18 List
;;;                                   } 17 DeclItem
;;;                                 } 16 List
Cprint_hex:
;;;                                 { 16 CompoundStatement
;;;                                   { 17 List
;;;                                     { 18 IfElseStatement
;;;                                       { 19 Expr l >= r
;;;                                         { 20 TypeName (internal)
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = unsigned int (82000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                         } 20 TypeName (internal)
;;;                                         { 20 Expression (variable name)
;;;                                           expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                         } 20 Expression (variable name)
;--     l >= r
        SHS     RR, #0x1000
;;;                                       } 19 Expr l >= r
;--     branch_false
        JMP     RRZ, L17_endif_37
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = dest
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr l[r]
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = const char (20100)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = hex
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l[r]
;;;                                               { 23 Expr l & r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = int (80000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expr l >> r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = int (80000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     l >> r
        ASR     RR, #0x000C
;;;                                                 } 24 Expr l >> r
;--     l & r
        AND     RR, #0x000F
;;;                                               } 23 Expr l & r
;--     scale_rr *1
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (hex)
;--     load_rr_var hex = 6(FP), SP at -2 (16 bit)
        MOVE    8(SP), RR
;;;                                               } 23 Expression (variable name)
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     + (element)
        ADD     LL, RR
;;;                                             } 22 Expr l[r]
;--     content
        MOVE    (RR), RS
;;;                                           } 21 Expr l[r]
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                           { 21 Expr * r
;;;                                             { 22 Expr l - r
;;;                                               { 23 Expr ++r
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                               } 23 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                             } 22 Expr l - r
;;;                                           } 21 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
L17_endif_37:
;;;                                     } 18 IfElseStatement
;;;                                     { 18 IfElseStatement
;;;                                       { 19 Expr l >= r
;;;                                         { 20 TypeName (internal)
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = unsigned int (82000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                         } 20 TypeName (internal)
;;;                                         { 20 Expression (variable name)
;;;                                           expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                         } 20 Expression (variable name)
;--     l >= r
        SHS     RR, #0x0100
;;;                                       } 19 Expr l >= r
;--     branch_false
        JMP     RRZ, L17_endif_38
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = dest
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr l[r]
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = const char (20100)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = hex
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l[r]
;;;                                               { 23 Expr l & r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = int (80000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expr l >> r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = int (80000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     l >> r
        ASR     RR, #0x0008
;;;                                                 } 24 Expr l >> r
;--     l & r
        AND     RR, #0x000F
;;;                                               } 23 Expr l & r
;--     scale_rr *1
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (hex)
;--     load_rr_var hex = 6(FP), SP at -2 (16 bit)
        MOVE    8(SP), RR
;;;                                               } 23 Expression (variable name)
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     + (element)
        ADD     LL, RR
;;;                                             } 22 Expr l[r]
;--     content
        MOVE    (RR), RS
;;;                                           } 21 Expr l[r]
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                           { 21 Expr * r
;;;                                             { 22 Expr l - r
;;;                                               { 23 Expr ++r
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                               } 23 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                             } 22 Expr l - r
;;;                                           } 21 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
L17_endif_38:
;;;                                     } 18 IfElseStatement
;;;                                     { 18 IfElseStatement
;;;                                       { 19 Expr l >= r
;;;                                         { 20 TypeName (internal)
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = unsigned int (82000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                         } 20 TypeName (internal)
;;;                                         { 20 Expression (variable name)
;;;                                           expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                         } 20 Expression (variable name)
;--     l >= r
        SHS     RR, #0x0010
;;;                                       } 19 Expr l >= r
;--     branch_false
        JMP     RRZ, L17_endif_39
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = dest
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr l[r]
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = const char (20100)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = hex
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l[r]
;;;                                               { 23 Expr l & r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = int (80000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expr l >> r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = int (80000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     l >> r
        ASR     RR, #0x0004
;;;                                                 } 24 Expr l >> r
;--     l & r
        AND     RR, #0x000F
;;;                                               } 23 Expr l & r
;--     scale_rr *1
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (hex)
;--     load_rr_var hex = 6(FP), SP at -2 (16 bit)
        MOVE    8(SP), RR
;;;                                               } 23 Expression (variable name)
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     + (element)
        ADD     LL, RR
;;;                                             } 22 Expr l[r]
;--     content
        MOVE    (RR), RS
;;;                                           } 21 Expr l[r]
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                           { 21 Expr * r
;;;                                             { 22 Expr l - r
;;;                                               { 23 Expr ++r
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                               } 23 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                             } 22 Expr l - r
;;;                                           } 21 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
L17_endif_39:
;;;                                     } 18 IfElseStatement
;;;                                     { 18 ExpressionStatement
;;;                                       { 19 Expr l = r
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = char (20000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = dest
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                         { 20 Expr l[r]
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = const char (20100)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = hex
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr l[r]
;;;                                             { 22 Expr l & r
;;;                                               { 23 TypeName (internal)
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = unsigned int (82000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                               } 23 TypeName (internal)
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                               } 23 Expression (variable name)
;--     l & r
        AND     RR, #0x000F
;;;                                             } 22 Expr l & r
;--     scale_rr *1
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (hex)
;--     load_rr_var hex = 6(FP), SP at -2 (16 bit)
        MOVE    8(SP), RR
;;;                                             } 22 Expression (variable name)
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     + (element)
        ADD     LL, RR
;;;                                           } 21 Expr l[r]
;--     content
        MOVE    (RR), RS
;;;                                         } 20 Expr l[r]
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                         { 20 Expr * r
;;;                                           { 21 Expr l - r
;;;                                             { 22 Expr ++r
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                               } 23 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                             } 22 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                           } 21 Expr l - r
;;;                                         } 20 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                       } 19 Expr l = r
;;;                                     } 18 ExpressionStatement
;;;                                     { 18 ExpressionStatement
;;;                                       { 19 Expr l = r
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = char (20000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = dest
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                         { 20 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                         } 20 NumericExpression (constant 0 = 0x0)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                         { 20 Expr * r
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                           } 21 Expression (variable name)
;;;                                         } 20 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                       } 19 Expr l = r
;;;                                     } 18 ExpressionStatement
;;;                                   } 17 List
;--     pop 0 bytes
;;;                                 } 16 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                 { 16 FunctionDefinition
;;;                                   { 17 TypeName
;;;                                     { 18 TypeSpecifier (all)
;;;                                       spec = void (10000)
;;;                                     } 18 TypeSpecifier (all)
;;;                                     { 18 List
;;;                                       { 19 DeclItem
;;;                                         what = DECL_NAME
;;;                                         name = print_unsigned
;;;                                       } 19 DeclItem
;;;                                     } 18 List
;;;                                   } 17 TypeName
;;;                                   { 17 List
;;;                                     { 18 DeclItem
;;;                                       what = DECL_NAME
;;;                                       name = print_unsigned
;;;                                     } 18 DeclItem
;;;                                     { 18 DeclItem
;;;                                       what = DECL_FUN
;;;                                       { 19 List
;;;                                         { 20 ParameterDeclaration
;;;                                           isEllipsis = false
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_POINTER
;;;                                                 { 24 List
;;;                                                   { 25 Ptr
;;;                                                   } 25 Ptr
;;;                                                 } 24 List
;;;                                               } 23 DeclItem
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = dest
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                         } 20 ParameterDeclaration
;;;                                         { 20 ParameterDeclaration
;;;                                           isEllipsis = false
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = unsigned int (82000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = value
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                         } 20 ParameterDeclaration
;;;                                       } 19 List
;;;                                     } 18 DeclItem
;;;                                   } 17 List
Cprint_unsigned:
;;;                                   { 17 CompoundStatement
;;;                                     { 18 List
;;;                                       { 19 IfElseStatement
;;;                                         { 20 Expr l >= r
;;;                                           { 21 TypeName (internal)
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = unsigned int (82000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                           } 21 TypeName (internal)
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                           } 21 Expression (variable name)
;--     l >= r
        SHS     RR, #0x2710
;;;                                         } 20 Expr l >= r
;--     branch_false
        JMP     RRZ, L18_endif_40
;;;                                         { 20 ExpressionStatement
;;;                                           { 21 Expr l = r
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = dest
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l + r
;;;                                               { 23 Expr l / r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = unsigned int (82000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     l / r
        MOVE    RR, LL
        MOVE    #0x2710, RR
;--     l / r
        DI
        DIV_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                               } 23 Expr l / r
;--     l + r
        ADD     RR, #0x0030
;;;                                             } 22 Expr l + r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                             { 22 Expr * r
;;;                                               { 23 Expr l - r
;;;                                                 { 24 Expr ++r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                                 } 24 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                               } 23 Expr l - r
;;;                                             } 22 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                           } 21 Expr l = r
;;;                                         } 20 ExpressionStatement
L18_endif_40:
;;;                                       } 19 IfElseStatement
;;;                                       { 19 IfElseStatement
;;;                                         { 20 Expr l >= r
;;;                                           { 21 TypeName (internal)
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = unsigned int (82000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                           } 21 TypeName (internal)
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                           } 21 Expression (variable name)
;--     l >= r
        SHS     RR, #0x03E8
;;;                                         } 20 Expr l >= r
;--     branch_false
        JMP     RRZ, L18_endif_41
;;;                                         { 20 ExpressionStatement
;;;                                           { 21 Expr l = r
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = dest
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l + r
;;;                                               { 23 Expr l % r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = unsigned int (82000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expr l / r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = unsigned int (82000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     l / r
        MOVE    RR, LL
        MOVE    #0x03E8, RR
;--     l / r
        DI
        DIV_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                 } 24 Expr l / r
;--     l % r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l % r
        DI
        DIV_IU
        CALL    mult_div
        MOD_FIN
        EI
;;;                                               } 23 Expr l % r
;--     l + r
        ADD     RR, #0x0030
;;;                                             } 22 Expr l + r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                             { 22 Expr * r
;;;                                               { 23 Expr l - r
;;;                                                 { 24 Expr ++r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                                 } 24 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                               } 23 Expr l - r
;;;                                             } 22 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                           } 21 Expr l = r
;;;                                         } 20 ExpressionStatement
L18_endif_41:
;;;                                       } 19 IfElseStatement
;;;                                       { 19 IfElseStatement
;;;                                         { 20 Expr l >= r
;;;                                           { 21 TypeName (internal)
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = unsigned int (82000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                           } 21 TypeName (internal)
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                           } 21 Expression (variable name)
;--     l >= r
        SHS     RR, #0x0064
;;;                                         } 20 Expr l >= r
;--     branch_false
        JMP     RRZ, L18_endif_42
;;;                                         { 20 ExpressionStatement
;;;                                           { 21 Expr l = r
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = dest
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l + r
;;;                                               { 23 Expr l % r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = unsigned int (82000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expr l / r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = unsigned int (82000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     l / r
        MOVE    RR, LL
        MOVE    #0x0064, RR
;--     l / r
        DI
        DIV_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                 } 24 Expr l / r
;--     l % r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l % r
        DI
        DIV_IU
        CALL    mult_div
        MOD_FIN
        EI
;;;                                               } 23 Expr l % r
;--     l + r
        ADD     RR, #0x0030
;;;                                             } 22 Expr l + r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                             { 22 Expr * r
;;;                                               { 23 Expr l - r
;;;                                                 { 24 Expr ++r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                                 } 24 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                               } 23 Expr l - r
;;;                                             } 22 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                           } 21 Expr l = r
;;;                                         } 20 ExpressionStatement
L18_endif_42:
;;;                                       } 19 IfElseStatement
;;;                                       { 19 IfElseStatement
;;;                                         { 20 Expr l >= r
;;;                                           { 21 TypeName (internal)
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = unsigned int (82000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                           } 21 TypeName (internal)
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                           } 21 Expression (variable name)
;--     l >= r
        SHS     RR, #0x000A
;;;                                         } 20 Expr l >= r
;--     branch_false
        JMP     RRZ, L18_endif_43
;;;                                         { 20 ExpressionStatement
;;;                                           { 21 Expr l = r
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = dest
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l + r
;;;                                               { 23 Expr l % r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = unsigned int (82000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expr l / r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = unsigned int (82000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     l / r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l / r
        DI
        DIV_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                 } 24 Expr l / r
;--     l % r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l % r
        DI
        DIV_IU
        CALL    mult_div
        MOD_FIN
        EI
;;;                                               } 23 Expr l % r
;--     l + r
        ADD     RR, #0x0030
;;;                                             } 22 Expr l + r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                             { 22 Expr * r
;;;                                               { 23 Expr l - r
;;;                                                 { 24 Expr ++r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                                 } 24 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                               } 23 Expr l - r
;;;                                             } 22 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                           } 21 Expr l = r
;;;                                         } 20 ExpressionStatement
L18_endif_43:
;;;                                       } 19 IfElseStatement
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = dest
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 Expr l + r
;;;                                             { 22 Expr l % r
;;;                                               { 23 TypeName (internal)
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = unsigned int (82000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                               } 23 TypeName (internal)
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (value)
;--     load_rr_var value = 4(FP), SP at 0 (16 bit)
        MOVE    4(SP), RR
;;;                                               } 23 Expression (variable name)
;--     l % r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l % r
        DI
        DIV_IU
        CALL    mult_div
        MOD_FIN
        EI
;;;                                             } 22 Expr l % r
;--     l + r
        ADD     RR, #0x0030
;;;                                           } 21 Expr l + r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                           { 21 Expr * r
;;;                                             { 22 Expr l - r
;;;                                               { 23 Expr ++r
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var dest = 2(FP), SP at -1
        MOVE    RR, 3(SP)
;;;                                               } 23 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                             } 22 Expr l - r
;;;                                           } 21 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
;;;                                       { 19 ExpressionStatement
;;;                                         { 20 Expr l = r
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = char (20000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = dest
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                           } 21 NumericExpression (constant 0 = 0x0)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                           { 21 Expr * r
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (dest)
;--     load_rr_var dest = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                             } 22 Expression (variable name)
;;;                                           } 21 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                         } 20 Expr l = r
;;;                                       } 19 ExpressionStatement
;;;                                     } 18 List
;--     pop 0 bytes
;;;                                   } 17 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                   { 17 FunctionDefinition
;;;                                     { 18 TypeName
;;;                                       { 19 TypeSpecifier (all)
;;;                                         spec = int (80000)
;;;                                       } 19 TypeSpecifier (all)
;;;                                       { 19 List
;;;                                         { 20 DeclItem
;;;                                           what = DECL_NAME
;;;                                           name = print_item
;;;                                         } 20 DeclItem
;;;                                       } 19 List
;;;                                     } 18 TypeName
;;;                                     { 18 List
;;;                                       { 19 DeclItem
;;;                                         what = DECL_NAME
;;;                                         name = print_item
;;;                                       } 19 DeclItem
;;;                                       { 19 DeclItem
;;;                                         what = DECL_FUN
;;;                                         { 20 List
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = const char (20100)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_POINTER
;;;                                                   { 25 List
;;;                                                     { 26 Ptr
;;;                                                     } 26 Ptr
;;;                                                   } 25 List
;;;                                                 } 24 DeclItem
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = buffer
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = flags
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = sign
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = pad
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = const char (20100)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_POINTER
;;;                                                   { 25 List
;;;                                                     { 26 Ptr
;;;                                                     } 26 Ptr
;;;                                                   } 25 List
;;;                                                 } 24 DeclItem
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = alt
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = field_w
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = min_w
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                           { 21 ParameterDeclaration
;;;                                             isEllipsis = false
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = min_p
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                           } 21 ParameterDeclaration
;;;                                         } 20 List
;;;                                       } 19 DeclItem
;;;                                     } 18 List
Cprint_item:
;;;                                     { 18 CompoundStatement
;;;                                       { 19 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = filllen
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                         { 20 Initializer (skalar)
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 Initializer (skalar)
;;;                                       } 19 InitDeclarator
;;;                                       { 19 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = signlen
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                         { 20 Initializer (skalar)
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 Initializer (skalar)
;;;                                       } 19 InitDeclarator
;;;                                       { 19 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = altlen
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                         { 20 Initializer (skalar)
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 Initializer (skalar)
;;;                                       } 19 InitDeclarator
;;;                                       { 19 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = padlen
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                         { 20 Initializer (skalar)
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 Initializer (skalar)
;;;                                       } 19 InitDeclarator
;;;                                       { 19 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = buflen
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                         { 20 Initializer (skalar)
;;;                                           { 21 Expr l(r)
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = strlen
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 ParameterDeclaration
;;;                                               isEllipsis = false
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = const char (20100)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_POINTER
;;;                                                     { 26 List
;;;                                                       { 27 Ptr
;;;                                                       } 27 Ptr
;;;                                                     } 26 List
;;;                                                   } 25 DeclItem
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = buffer
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                             } 22 ParameterDeclaration
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at -8 (16 bit)
        MOVE    10(SP), RR
;;;                                             } 22 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cstrlen
;--     pop 2 bytes
        ADD     SP, #2
;;;                                           } 21 Expr l(r)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                         } 20 Initializer (skalar)
;;;                                       } 19 InitDeclarator
;;;                                       { 19 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = len
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                       } 19 InitDeclarator
;;;                                       { 19 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = i
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                       } 19 InitDeclarator
;;;                                       { 19 List
;;;                                         { 20 IfElseStatement
;;;                                           { 21 Expr l > r
;;;                                             { 22 TypeName (internal)
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                             } 22 TypeName (internal)
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (min_w)
;--     load_rr_var min_w = 11(FP), SP at -14 (16 bit)
        MOVE    25(SP), RR
;;;                                             } 22 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (buflen)
;--     load_rr_var buflen = -10(FP), SP at -14 (16 bit)
        MOVE    4(SP), RR
;;;                                             } 22 Expression (variable name)
;--     l > r
        SGT     LL, RR
;;;                                           } 21 Expr l > r
;--     branch_false
        JMP     RRZ, L19_endif_44
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l = r
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = int (80000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = padlen
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 Expr l - r
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (min_w)
;--     load_rr_var min_w = 11(FP), SP at -14 (16 bit)
        MOVE    25(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (buflen)
;--     load_rr_var buflen = -10(FP), SP at -14 (16 bit)
        MOVE    4(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     scale_rr *1
;--     l - r
        SUB     LL, RR
;--     scale *1
;;;                                               } 23 Expr l - r
;--     store_rr_var padlen = -8(FP), SP at -14
        MOVE    RR, 6(SP)
;;;                                             } 22 Expr l = r
;;;                                           } 21 ExpressionStatement
L19_endif_44:
;;;                                         } 20 IfElseStatement
;;;                                         { 20 IfElseStatement
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (sign)
;--     load_rr_var sign = 5(FP), SP at -14 (8 bit)
        MOVE    19(SP), RS
;;;                                           } 21 Expression (variable name)
;--     branch_false
        JMP     RRZ, L19_endif_45
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l = r
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = int (80000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = signlen
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                               } 23 NumericExpression (constant 1 = 0x1)
;--     store_rr_var signlen = -4(FP), SP at -14
        MOVE    RR, 10(SP)
;;;                                             } 22 Expr l = r
;;;                                           } 21 ExpressionStatement
L19_endif_45:
;;;                                         } 20 IfElseStatement
;;;                                         { 20 IfElseStatement
;;;                                           { 21 Expr l && r
;;;                                             { 22 TypeName (internal)
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                             } 22 TypeName (internal)
;;;                                             { 22 IfElseStatement
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (alt)
;--     load_rr_var alt = 7(FP), SP at -14 (16 bit)
        MOVE    21(SP), RR
;;;                                               } 23 Expression (variable name)
;--     branch_false
        JMP     RRZ, L19_endif_47
;;;                                               { 23 ExpressionStatement
;;;                                                 { 24 Expr l & r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = int (80000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (flags)
;--     load_rr_var flags = 4(FP), SP at -14 (8 bit)
        MOVE    18(SP), RS
;;;                                                   } 25 Expression (variable name)
;--     l & r
        AND     RR, #0x0001
;;;                                                 } 24 Expr l & r
;;;                                               } 23 ExpressionStatement
L19_endif_47:
;;;                                             } 22 IfElseStatement
;;;                                           } 21 Expr l && r
;--     branch_false
        JMP     RRZ, L19_endif_46
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l = r
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = int (80000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = altlen
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 Expr l(r)
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = int (80000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = strlen
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 ParameterDeclaration
;;;                                                   isEllipsis = false
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = const char (20100)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_POINTER
;;;                                                         { 28 List
;;;                                                           { 29 Ptr
;;;                                                           } 29 Ptr
;;;                                                         } 28 List
;;;                                                       } 27 DeclItem
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = buffer
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                 } 24 ParameterDeclaration
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (alt)
;--     load_rr_var alt = 7(FP), SP at -14 (16 bit)
        MOVE    21(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cstrlen
;--     pop 2 bytes
        ADD     SP, #2
;;;                                               } 23 Expr l(r)
;--     store_rr_var altlen = -6(FP), SP at -14
        MOVE    RR, 8(SP)
;;;                                             } 22 Expr l = r
;;;                                           } 21 ExpressionStatement
L19_endif_46:
;;;                                         } 20 IfElseStatement
;;;                                         { 20 ExpressionStatement
;;;                                           { 21 Expr l = r
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = len
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 Expr l + r
;;;                                               { 23 Expr l + r
;;;                                                 { 24 Expr l + r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (signlen)
;--     load_rr_var signlen = -4(FP), SP at -14 (16 bit)
        MOVE    10(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (altlen)
;--     load_rr_var altlen = -6(FP), SP at -14 (16 bit)
        MOVE    8(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                 } 24 Expr l + r
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (padlen)
;--     load_rr_var padlen = -8(FP), SP at -14 (16 bit)
        MOVE    6(SP), RR
;;;                                                 } 24 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                               } 23 Expr l + r
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (buflen)
;--     load_rr_var buflen = -10(FP), SP at -14 (16 bit)
        MOVE    4(SP), RR
;;;                                               } 23 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                             } 22 Expr l + r
;--     store_rr_var len = -12(FP), SP at -14
        MOVE    RR, 2(SP)
;;;                                           } 21 Expr l = r
;;;                                         } 20 ExpressionStatement
;;;                                         { 20 IfElseStatement
;;;                                           { 21 Expr l & r
;;;                                             { 22 TypeName (internal)
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                             } 22 TypeName (internal)
;;;                                             { 22 Expr ~ r
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (flags)
;--     load_rr_var flags = 4(FP), SP at -14 (8 bit)
        MOVE    18(SP), RS
;;;                                               } 23 Expression (variable name)
;--     16 bit ~ r
        NOT     RR
;;;                                             } 22 Expr ~ r
;--     l & r
        AND     RR, #0x0002
;;;                                           } 21 Expr l & r
;--     branch_false
        JMP     RRZ, L19_endif_48
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l(r)
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = void (10000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = print_n
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 Expr (l , r)
;;;                                                 { 24 ParameterDeclaration
;;;                                                   isEllipsis = false
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = int (80000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = count
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                 } 24 ParameterDeclaration
;;;                                                 { 24 Expr l - r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (field_w)
;--     load_rr_var field_w = 9(FP), SP at -14 (16 bit)
        MOVE    23(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (len)
;--     load_rr_var len = -12(FP), SP at -14 (16 bit)
        MOVE    2(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     scale_rr *1
;--     l - r
        SUB     LL, RR
;--     scale *1
;;;                                                 } 24 Expr l - r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                 { 24 ParameterDeclaration
;;;                                                   isEllipsis = false
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = char (20000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = c
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                 } 24 ParameterDeclaration
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (pad)
;--     load_rr_var pad = 6(FP), SP at -16 (8 bit)
        MOVE    22(SP), RS
;;;                                                 } 24 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                               } 23 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_n
;--     pop 3 bytes
        ADD     SP, #3
;;;                                             } 22 Expr l(r)
;;;                                           } 21 ExpressionStatement
L19_endif_48:
;;;                                         } 20 IfElseStatement
;;;                                         { 20 IfElseStatement
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (sign)
;--     load_rr_var sign = 5(FP), SP at -14 (8 bit)
        MOVE    19(SP), RS
;;;                                           } 21 Expression (variable name)
;--     branch_false
        JMP     RRZ, L19_endif_49
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l(r)
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = int (80000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = putchr
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 ParameterDeclaration
;;;                                                 isEllipsis = false
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = char (20000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = c
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                               } 23 ParameterDeclaration
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (sign)
;--     load_rr_var sign = 5(FP), SP at -14 (8 bit)
        MOVE    19(SP), RS
;;;                                               } 23 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                             } 22 Expr l(r)
;;;                                           } 21 ExpressionStatement
L19_endif_49:
;;;                                         } 20 IfElseStatement
;;;                                         { 20 IfElseStatement
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (alt)
;--     load_rr_var alt = 7(FP), SP at -14 (16 bit)
        MOVE    21(SP), RR
;;;                                           } 21 Expression (variable name)
;--     branch_false
        JMP     RRZ, L19_endif_50
;;;                                           { 21 CompoundStatement
;;;                                             { 22 List
;;;                                               { 23 IfElseStatement
;;;                                                 { 24 Expr l & r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = int (80000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (flags)
;--     load_rr_var flags = 4(FP), SP at -14 (8 bit)
        MOVE    18(SP), RS
;;;                                                   } 25 Expression (variable name)
;--     l & r
        AND     RR, #0x0001
;;;                                                 } 24 Expr l & r
;--     branch_false
        JMP     RRZ, L19_endif_51
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l(r)
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = void (10000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = print_string
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 ParameterDeclaration
;;;                                                       isEllipsis = false
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (all)
;;;                                                           spec = const char (20100)
;;;                                                         } 28 TypeSpecifier (all)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_POINTER
;;;                                                             { 30 List
;;;                                                               { 31 Ptr
;;;                                                               } 31 Ptr
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = buffer
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                     } 26 ParameterDeclaration
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (alt)
;--     load_rr_var alt = 7(FP), SP at -14 (16 bit)
        MOVE    21(SP), RR
;;;                                                     } 26 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cprint_string
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                   } 25 Expr l(r)
;;;                                                 } 24 ExpressionStatement
L19_endif_51:
;;;                                               } 23 IfElseStatement
;;;                                             } 22 List
;--     pop 0 bytes
;;;                                           } 21 CompoundStatement
L19_endif_50:
;;;                                         } 20 IfElseStatement
;;;                                         { 20 for Statement
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l = r
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = int (80000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = i
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                               } 23 NumericExpression (constant 0 = 0x0)
;--     store_rr_var i = -14(FP), SP at -14
        MOVE    RR, 0(SP)
;;;                                             } 22 Expr l = r
;;;                                           } 21 ExpressionStatement
;--     branch
        JMP     L19_tst_52
L19_loop_52:
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l(r)
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = int (80000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = putchr
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 ParameterDeclaration
;;;                                                 isEllipsis = false
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = char (20000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = c
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                               } 23 ParameterDeclaration
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (min_p)
;--     load_rr_var min_p = 13(FP), SP at -14 (8 bit)
        MOVE    27(SP), RS
;;;                                               } 23 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                             } 22 Expr l(r)
;;;                                           } 21 ExpressionStatement
L19_cont_52:
;;;                                           { 21 Expr l - r
;;;                                             { 22 Expr ++r
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (i)
;--     load_rr_var i = -14(FP), SP at -14 (16 bit)
        MOVE    0(SP), RR
;;;                                               } 23 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var i = -14(FP), SP at -14
        MOVE    RR, 0(SP)
;;;                                             } 22 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                           } 21 Expr l - r
L19_tst_52:
;;;                                           { 21 Expr l < r
;;;                                             { 22 TypeName (internal)
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                             } 22 TypeName (internal)
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (i)
;--     load_rr_var i = -14(FP), SP at -14 (16 bit)
        MOVE    0(SP), RR
;;;                                             } 22 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (padlen)
;--     load_rr_var padlen = -8(FP), SP at -14 (16 bit)
        MOVE    6(SP), RR
;;;                                             } 22 Expression (variable name)
;--     l < r
        SLT     LL, RR
;;;                                           } 21 Expr l < r
;--     branch_true
        JMP     RRNZ, L19_loop_52
L19_brk_53:
;;;                                         } 20 for Statement
;;;                                         { 20 ExpressionStatement
;;;                                           { 21 Expr l(r)
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = void (10000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = print_string
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 ParameterDeclaration
;;;                                               isEllipsis = false
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = const char (20100)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_POINTER
;;;                                                     { 26 List
;;;                                                       { 27 Ptr
;;;                                                       } 27 Ptr
;;;                                                     } 26 List
;;;                                                   } 25 DeclItem
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = buffer
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                             } 22 ParameterDeclaration
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (buffer)
;--     load_rr_var buffer = 2(FP), SP at -14 (16 bit)
        MOVE    16(SP), RR
;;;                                             } 22 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cprint_string
;--     pop 2 bytes
        ADD     SP, #2
;;;                                           } 21 Expr l(r)
;;;                                         } 20 ExpressionStatement
;;;                                         { 20 IfElseStatement
;;;                                           { 21 Expr l & r
;;;                                             { 22 TypeName (internal)
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = int (80000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                             } 22 TypeName (internal)
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (flags)
;--     load_rr_var flags = 4(FP), SP at -14 (8 bit)
        MOVE    18(SP), RS
;;;                                             } 22 Expression (variable name)
;--     l & r
        AND     RR, #0x0002
;;;                                           } 21 Expr l & r
;--     branch_false
        JMP     RRZ, L19_endif_54
;;;                                           { 21 ExpressionStatement
;;;                                             { 22 Expr l(r)
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = void (10000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = print_n
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 Expr (l , r)
;;;                                                 { 24 ParameterDeclaration
;;;                                                   isEllipsis = false
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = int (80000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = count
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                 } 24 ParameterDeclaration
;;;                                                 { 24 Expr l - r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (field_w)
;--     load_rr_var field_w = 9(FP), SP at -14 (16 bit)
        MOVE    23(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (len)
;--     load_rr_var len = -12(FP), SP at -14 (16 bit)
        MOVE    2(SP), RR
;;;                                                   } 25 Expression (variable name)
;--     scale_rr *1
;--     l - r
        SUB     LL, RR
;--     scale *1
;;;                                                 } 24 Expr l - r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                 { 24 ParameterDeclaration
;;;                                                   isEllipsis = false
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = char (20000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = c
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                 } 24 ParameterDeclaration
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (pad)
;--     load_rr_var pad = 6(FP), SP at -16 (8 bit)
        MOVE    22(SP), RS
;;;                                                 } 24 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                               } 23 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_n
;--     pop 3 bytes
        ADD     SP, #3
;;;                                             } 22 Expr l(r)
;;;                                           } 21 ExpressionStatement
L19_endif_54:
;;;                                         } 20 IfElseStatement
;;;                                         { 20 return Statement
;;;                                           { 21 Expression (variable name)
;;;                                             expr_type = "identifier" (len)
;--     load_rr_var len = -12(FP), SP at -14 (16 bit)
        MOVE    2(SP), RR
;;;                                           } 21 Expression (variable name)
;--     ret
        ADD     SP, #14
        RET
;;;                                         } 20 return Statement
;;;                                       } 19 List
;--     pop 14 bytes
        ADD     SP, #14
;;;                                     } 18 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                     { 18 FunctionDefinition
;;;                                       { 19 TypeName
;;;                                         { 20 TypeSpecifier (all)
;;;                                           spec = int (80000)
;;;                                         } 20 TypeSpecifier (all)
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = printf
;;;                                           } 21 DeclItem
;;;                                         } 20 List
;;;                                       } 19 TypeName
;;;                                       { 19 List
;;;                                         { 20 DeclItem
;;;                                           what = DECL_NAME
;;;                                           name = printf
;;;                                         } 20 DeclItem
;;;                                         { 20 DeclItem
;;;                                           what = DECL_FUN
;;;                                           { 21 List
;;;                                             { 22 ParameterDeclaration
;;;                                               isEllipsis = true
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = const char (20100)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_POINTER
;;;                                                     { 26 List
;;;                                                       { 27 Ptr
;;;                                                       } 27 Ptr
;;;                                                     } 26 List
;;;                                                   } 25 DeclItem
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = format
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                             } 22 ParameterDeclaration
;;;                                           } 21 List
;;;                                         } 20 DeclItem
;;;                                       } 19 List
Cprintf:
;;;                                       { 19 CompoundStatement
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_POINTER
;;;                                               { 23 List
;;;                                                 { 24 Ptr
;;;                                                 } 24 Ptr
;;;                                                 { 24 Ptr
;;;                                                 } 24 Ptr
;;;                                               } 23 List
;;;                                             } 22 DeclItem
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = args
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                           { 21 Initializer (skalar)
;;;                                             { 22 Expr l + r
;;;                                               { 23 Expr & r
;--     load_address format = 2(FP), SP at 0
        LEA     2(SP), RR
;;;                                               } 23 Expr & r
;--     l + r
        ADD     RR, #0x0002
;;;                                             } 22 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                           } 21 Initializer (skalar)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = len
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                           { 21 Initializer (skalar)
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                           } 21 Initializer (skalar)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = c
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = flags
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = sign
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = pad
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_POINTER
;;;                                               { 23 List
;;;                                                 { 24 Ptr
;;;                                                 } 24 Ptr
;;;                                               } 23 List
;;;                                             } 22 DeclItem
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = alt
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = field_w
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = min_w
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_POINTER
;;;                                               { 23 List
;;;                                                 { 24 Ptr
;;;                                                 } 24 Ptr
;;;                                               } 23 List
;;;                                             } 22 DeclItem
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = which_w
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = buffer
;;;                                             } 22 DeclItem
;;;                                             { 22 DeclItem
;;;                                               what = DECL_ARRAY
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;--     push_zero 12 bytes
        CLRW    -(SP)
        CLRW    -(SP)
        CLRW    -(SP)
        CLRW    -(SP)
        CLRW    -(SP)
        CLRW    -(SP)
;;;                                         } 20 InitDeclarator
;;;                                         { 20 List
;;;                                           { 21 while Statement
;--     branch
        JMP     L20_cont_55
L20_loop_55:
;;;                                             { 22 CompoundStatement
;;;                                               { 23 List
;;;                                                 { 24 IfElseStatement
;;;                                                   { 25 Expr l != r
;;;                                                     { 26 TypeName (internal)
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = int (80000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                     } 26 TypeName (internal)
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (c)
;--     load_rr_var c = -5(FP), SP at -28 (8 bit)
        MOVE    23(SP), RS
;;;                                                     } 26 Expression (variable name)
;--     l != r
        SNE     RR, #0x0025
;;;                                                   } 25 Expr l != r
;--     branch_false
        JMP     RRZ, L20_endif_57
;;;                                                   { 25 CompoundStatement
;;;                                                     { 26 List
;;;                                                       { 27 ExpressionStatement
;;;                                                         { 28 Expr l += r
;;;                                                           { 29 TypeName
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = int (80000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = len
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;;;                                                           } 29 TypeName
;;;                                                           { 29 Expr l + r
;;;                                                             { 30 Expr l(r)
;;;                                                               { 31 TypeName
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = int (80000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                                 { 32 List
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_NAME
;;;                                                                     name = putchr
;;;                                                                   } 33 DeclItem
;;;                                                                 } 32 List
;;;                                                               } 31 TypeName
;;;                                                               { 31 ParameterDeclaration
;;;                                                                 isEllipsis = false
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = char (20000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = c
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                               } 31 ParameterDeclaration
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (c)
;--     load_rr_var c = -5(FP), SP at -28 (8 bit)
        MOVE    23(SP), RS
;;;                                                               } 31 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                             } 30 Expr l(r)
;;;                                                             { 30 Expression (variable name)
;;;                                                               expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                             } 30 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                           } 29 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                         } 28 Expr l += r
;;;                                                       } 27 ExpressionStatement
;;;                                                       { 27 break/continue Statement
;--     branch
        JMP     L20_cont_55
;;;                                                       } 27 break/continue Statement
;;;                                                     } 26 List
;--     pop 0 bytes
;;;                                                   } 25 CompoundStatement
L20_endif_57:
;;;                                                 } 24 IfElseStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = char (20000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = flags
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                     } 26 NumericExpression (constant 0 = 0x0)
;--     store_rr_var flags = -6(FP), SP at -28
        MOVE    R, 22(SP)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = char (20000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = sign
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                     } 26 NumericExpression (constant 0 = 0x0)
;--     store_rr_var sign = -7(FP), SP at -28
        MOVE    R, 21(SP)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = char (20000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = pad
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 NumericExpression (constant 32 = 0x20)
;--     load_rr_constant
        MOVE    #0x0020, RR
;;;                                                     } 26 NumericExpression (constant 32 = 0x20)
;--     store_rr_var pad = -8(FP), SP at -28
        MOVE    R, 20(SP)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = int (80000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = field_w
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                     } 26 NumericExpression (constant 0 = 0x0)
;--     store_rr_var field_w = -12(FP), SP at -28
        MOVE    RR, 16(SP)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = int (80000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = min_w
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                     } 26 NumericExpression (constant 0 = 0x0)
;--     store_rr_var min_w = -14(FP), SP at -28
        MOVE    RR, 14(SP)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = unsigned int (82000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_POINTER
;;;                                                           { 29 List
;;;                                                             { 30 Ptr
;;;                                                             } 30 Ptr
;;;                                                           } 29 List
;;;                                                         } 28 DeclItem
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = which_w
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 Expr & r
;--     load_address field_w = -12(FP), SP at -28
        LEA     16(SP), RR
;;;                                                     } 26 Expr & r
;--     store_rr_var which_w = -16(FP), SP at -28
        MOVE    RR, 12(SP)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 for Statement
;;;                                                   { 25 ExpressionStatement
;;;                                                   } 25 ExpressionStatement
L20_loop_58:
;;;                                                   { 25 CompoundStatement
;;;                                                     { 26 List
;;;                                                       { 27 SwitchStatement
;;;                                                         { 28 Expr l = r
;;;                                                           { 29 TypeName
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = char (20000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = c
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;;;                                                           } 29 TypeName
;;;                                                           { 29 Expr * r
;;;                                                             { 30 Expr l - r
;;;                                                               { 31 Expr ++r
;;;                                                                 { 32 Expression (variable name)
;;;                                                                   expr_type = "identifier" (format)
;--     load_rr_var format = 2(FP), SP at -28 (16 bit)
        MOVE    30(SP), RR
;;;                                                                 } 32 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var format = 2(FP), SP at -28
        MOVE    RR, 30(SP)
;;;                                                               } 31 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                             } 30 Expr l - r
;--     content
        MOVE    (RR), RS
;;;                                                           } 29 Expr * r
;--     store_rr_var c = -5(FP), SP at -28
        MOVE    R, 23(SP)
;;;                                                         } 28 Expr l = r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     branch_case (8 bit)
        SEQ     LL, #0x0058
        JMP     RRNZ, L20_case_60_0058
;--     branch_case (8 bit)
        SEQ     LL, #0x0064
        JMP     RRNZ, L20_case_60_0064
;--     branch_case (8 bit)
        SEQ     LL, #0x0073
        JMP     RRNZ, L20_case_60_0073
;--     branch_case (8 bit)
        SEQ     LL, #0x0075
        JMP     RRNZ, L20_case_60_0075
;--     branch_case (8 bit)
        SEQ     LL, #0x0078
        JMP     RRNZ, L20_case_60_0078
;--     branch_case (8 bit)
        SEQ     LL, #0x0063
        JMP     RRNZ, L20_case_60_0063
;--     branch_case (8 bit)
        SEQ     LL, #0x0023
        JMP     RRNZ, L20_case_60_0023
;--     branch_case (8 bit)
        SEQ     LL, #0x002D
        JMP     RRNZ, L20_case_60_002D
;--     branch_case (8 bit)
        SEQ     LL, #0x0020
        JMP     RRNZ, L20_case_60_0020
;--     branch_case (8 bit)
        SEQ     LL, #0x002B
        JMP     RRNZ, L20_case_60_002B
;--     branch_case (8 bit)
        SEQ     LL, #0x002E
        JMP     RRNZ, L20_case_60_002E
;--     branch_case (8 bit)
        SEQ     LL, #0x0030
        JMP     RRNZ, L20_case_60_0030
;--     branch_case (8 bit)
        SEQ     LL, #0x0031
        JMP     RRNZ, L20_case_60_0031
;--     branch_case (8 bit)
        SEQ     LL, #0x0032
        JMP     RRNZ, L20_case_60_0032
;--     branch_case (8 bit)
        SEQ     LL, #0x0033
        JMP     RRNZ, L20_case_60_0033
;--     branch_case (8 bit)
        SEQ     LL, #0x0034
        JMP     RRNZ, L20_case_60_0034
;--     branch_case (8 bit)
        SEQ     LL, #0x0035
        JMP     RRNZ, L20_case_60_0035
;--     branch_case (8 bit)
        SEQ     LL, #0x0036
        JMP     RRNZ, L20_case_60_0036
;--     branch_case (8 bit)
        SEQ     LL, #0x0037
        JMP     RRNZ, L20_case_60_0037
;--     branch_case (8 bit)
        SEQ     LL, #0x0038
        JMP     RRNZ, L20_case_60_0038
;--     branch_case (8 bit)
        SEQ     LL, #0x0039
        JMP     RRNZ, L20_case_60_0039
;--     branch_case (8 bit)
        SEQ     LL, #0x002A
        JMP     RRNZ, L20_case_60_002A
;--     branch_case (8 bit)
        SEQ     LL, #0x0000
        JMP     RRNZ, L20_case_60_0000
;--     branch
        JMP     L20_deflt_60
;;;                                                         { 28 CompoundStatement
;;;                                                           { 29 List
;;;                                                             { 30 case Statement
L20_case_60_0058:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l(r)
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = void (10000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = print_hex
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr (l , r)
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = const char (20100)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = hex
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 StringExpression
;--     load_rr_string
        MOVE    #Cstr_36, RR
;;;                                                                     } 34 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = unsigned int (82000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = value
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 Expression (cast)r
;;;                                                                         { 36 Expr * r
;;;                                                                           { 37 Expr l - r
;;;                                                                             { 38 Expr ++r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -30 (16 bit)
        MOVE    28(SP), RR
;;;                                                                               } 39 Expression (variable name)
;--     ++
        ADD     RR, #0x0002
;--     store_rr_var args = -2(FP), SP at -30
        MOVE    RR, 28(SP)
;;;                                                                             } 38 Expr ++r
;--     l - r
        SUB     RR, #0x0002
;;;                                                                           } 37 Expr l - r
;--     content
        MOVE    (RR), RR
;;;                                                                         } 36 Expr * r
;;;                                                                       } 35 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = dest
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -32
        LEA     4(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                     } 34 Expr (l , r)
;;;                                                                   } 33 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_hex
;--     pop 6 bytes
        ADD     SP, #6
;;;                                                                 } 32 Expr l(r)
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l += r
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = len
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 Expr l + r
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = print_item
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = min_p
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 48 = 0x30)
;--     load_rr_constant
        MOVE    #0x0030, RR
;;;                                                                       } 35 NumericExpression (constant 48 = 0x30)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = int (80000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = min_w
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (min_w)
;--     load_rr_var min_w = -14(FP), SP at -29 (16 bit)
        MOVE    15(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 Expr (l , r)
;;;                                                                           { 37 ParameterDeclaration
;;;                                                                             isEllipsis = false
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = field_w
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                           } 37 ParameterDeclaration
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (field_w)
;--     load_rr_var field_w = -12(FP), SP at -31 (16 bit)
        MOVE    19(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                           { 37 Expr (l , r)
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = false
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = const char (20100)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_POINTER
;;;                                                                                     { 42 List
;;;                                                                                       { 43 Ptr
;;;                                                                                       } 43 Ptr
;;;                                                                                     } 42 List
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = alt
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 StringExpression
;--     load_rr_string
        MOVE    #Cstr_37, RR
;;;                                                                             } 38 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = false
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = char (20000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = pad
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (pad)
;--     load_rr_var pad = -8(FP), SP at -35 (8 bit)
        MOVE    27(SP), RS
;;;                                                                               } 39 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = false
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = char (20000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = sign
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (sign)
;--     load_rr_var sign = -7(FP), SP at -36 (8 bit)
        MOVE    29(SP), RS
;;;                                                                                 } 40 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                 { 40 Expr (l , r)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = char (20000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = flags
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (flags)
;--     load_rr_var flags = -6(FP), SP at -37 (8 bit)
        MOVE    31(SP), RS
;;;                                                                                   } 41 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = const char (20100)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_POINTER
;;;                                                                                           { 45 List
;;;                                                                                             { 46 Ptr
;;;                                                                                             } 46 Ptr
;;;                                                                                           } 45 List
;;;                                                                                         } 44 DeclItem
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = buffer
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -38
        LEA     10(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 } 40 Expr (l , r)
;;;                                                                               } 39 Expr (l , r)
;;;                                                                             } 38 Expr (l , r)
;;;                                                                           } 37 Expr (l , r)
;;;                                                                         } 36 Expr (l , r)
;;;                                                                       } 35 Expr (l , r)
;;;                                                                     } 34 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprint_item
;--     pop 12 bytes
        ADD     SP, #12
;;;                                                                   } 33 Expr l(r)
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                                   } 33 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                 } 32 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                               } 31 Expr l += r
;;;                                                             } 30 ExpressionStatement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0064:
;;;                                                               { 31 IfElseStatement
;;;                                                                 { 32 Expr l < r
;;;                                                                   { 33 TypeName (internal)
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = int (80000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                   } 33 TypeName (internal)
;;;                                                                   { 33 Expression (cast)r
;;;                                                                     { 34 Expr * r
;;;                                                                       { 35 Expression (variable name)
;;;                                                                         expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -28 (16 bit)
        MOVE    26(SP), RR
;;;                                                                       } 35 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                     } 34 Expr * r
;;;                                                                   } 33 Expression (cast)r
;--     l < r
        SLT     RR, #0x0000
;;;                                                                 } 32 Expr l < r
;--     branch_false
        JMP     RRZ, L20_endif_61
;;;                                                                 { 32 CompoundStatement
;;;                                                                   { 33 List
;;;                                                                     { 34 ExpressionStatement
;;;                                                                       { 35 Expr l = r
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = sign
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                         { 36 NumericExpression (constant 45 = 0x2D)
;--     load_rr_constant
        MOVE    #0x002D, RR
;;;                                                                         } 36 NumericExpression (constant 45 = 0x2D)
;--     store_rr_var sign = -7(FP), SP at -28
        MOVE    R, 21(SP)
;;;                                                                       } 35 Expr l = r
;;;                                                                     } 34 ExpressionStatement
;;;                                                                     { 34 ExpressionStatement
;;;                                                                       { 35 Expr l = r
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = const char (20100)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = args
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                         { 36 Expression (cast)r
;;;                                                                           { 37 Expr - r
;;;                                                                             { 38 Expression (cast)r
;;;                                                                               { 39 Expr * r
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -28 (16 bit)
        MOVE    26(SP), RR
;;;                                                                                 } 40 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                               } 39 Expr * r
;;;                                                                             } 38 Expression (cast)r
;--     16 bit - r
        NEG     RR
;;;                                                                           } 37 Expr - r
;;;                                                                         } 36 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 Expr * r
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -30 (16 bit)
        MOVE    28(SP), RR
;;;                                                                           } 37 Expression (variable name)
;;;                                                                         } 36 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                       } 35 Expr l = r
;;;                                                                     } 34 ExpressionStatement
;;;                                                                   } 33 List
;--     pop 0 bytes
;;;                                                                 } 32 CompoundStatement
L20_endif_61:
;;;                                                               } 31 IfElseStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l(r)
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = void (10000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = print_unsigned
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 Expr (l , r)
;;;                                                                   { 33 ParameterDeclaration
;;;                                                                     isEllipsis = false
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = unsigned int (82000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = value
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                   } 33 ParameterDeclaration
;;;                                                                   { 33 Expression (cast)r
;;;                                                                     { 34 Expr * r
;;;                                                                       { 35 Expr l - r
;;;                                                                         { 36 Expr ++r
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -28 (16 bit)
        MOVE    26(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     ++
        ADD     RR, #0x0002
;--     store_rr_var args = -2(FP), SP at -28
        MOVE    RR, 26(SP)
;;;                                                                         } 36 Expr ++r
;--     l - r
        SUB     RR, #0x0002
;;;                                                                       } 35 Expr l - r
;--     content
        MOVE    (RR), RR
;;;                                                                     } 34 Expr * r
;;;                                                                   } 33 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 ParameterDeclaration
;;;                                                                     isEllipsis = false
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = char (20000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_POINTER
;;;                                                                           { 37 List
;;;                                                                             { 38 Ptr
;;;                                                                             } 38 Ptr
;;;                                                                           } 37 List
;;;                                                                         } 36 DeclItem
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = dest
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                   } 33 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -30
        LEA     2(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                 } 32 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_unsigned
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                               } 31 Expr l(r)
;;;                                                             } 30 ExpressionStatement
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l += r
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = len
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 Expr l + r
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = print_item
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = min_p
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 48 = 0x30)
;--     load_rr_constant
        MOVE    #0x0030, RR
;;;                                                                       } 35 NumericExpression (constant 48 = 0x30)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = int (80000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = min_w
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (min_w)
;--     load_rr_var min_w = -14(FP), SP at -29 (16 bit)
        MOVE    15(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 Expr (l , r)
;;;                                                                           { 37 ParameterDeclaration
;;;                                                                             isEllipsis = false
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = field_w
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                           } 37 ParameterDeclaration
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (field_w)
;--     load_rr_var field_w = -12(FP), SP at -31 (16 bit)
        MOVE    19(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                           { 37 Expr (l , r)
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = false
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = const char (20100)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_POINTER
;;;                                                                                     { 42 List
;;;                                                                                       { 43 Ptr
;;;                                                                                       } 43 Ptr
;;;                                                                                     } 42 List
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = alt
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 StringExpression
;--     load_rr_string
        MOVE    #Cstr_38, RR
;;;                                                                             } 38 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = false
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = char (20000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = pad
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (pad)
;--     load_rr_var pad = -8(FP), SP at -35 (8 bit)
        MOVE    27(SP), RS
;;;                                                                               } 39 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = false
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = char (20000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = sign
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (sign)
;--     load_rr_var sign = -7(FP), SP at -36 (8 bit)
        MOVE    29(SP), RS
;;;                                                                                 } 40 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                 { 40 Expr (l , r)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = char (20000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = flags
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (flags)
;--     load_rr_var flags = -6(FP), SP at -37 (8 bit)
        MOVE    31(SP), RS
;;;                                                                                   } 41 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = const char (20100)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_POINTER
;;;                                                                                           { 45 List
;;;                                                                                             { 46 Ptr
;;;                                                                                             } 46 Ptr
;;;                                                                                           } 45 List
;;;                                                                                         } 44 DeclItem
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = buffer
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -38
        LEA     10(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 } 40 Expr (l , r)
;;;                                                                               } 39 Expr (l , r)
;;;                                                                             } 38 Expr (l , r)
;;;                                                                           } 37 Expr (l , r)
;;;                                                                         } 36 Expr (l , r)
;;;                                                                       } 35 Expr (l , r)
;;;                                                                     } 34 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprint_item
;--     pop 12 bytes
        ADD     SP, #12
;;;                                                                   } 33 Expr l(r)
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                                   } 33 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                 } 32 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                               } 31 Expr l += r
;;;                                                             } 30 ExpressionStatement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0073:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l += r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = int (80000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = len
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = print_item
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = char (20000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = min_p
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 NumericExpression (constant 32 = 0x20)
;--     load_rr_constant
        MOVE    #0x0020, RR
;;;                                                                         } 36 NumericExpression (constant 32 = 0x20)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                         { 36 Expr (l , r)
;;;                                                                           { 37 ParameterDeclaration
;;;                                                                             isEllipsis = false
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = min_w
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                           } 37 ParameterDeclaration
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (min_w)
;--     load_rr_var min_w = -14(FP), SP at -29 (16 bit)
        MOVE    15(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                           { 37 Expr (l , r)
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = false
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = field_w
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (field_w)
;--     load_rr_var field_w = -12(FP), SP at -31 (16 bit)
        MOVE    19(SP), RR
;;;                                                                             } 38 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = false
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = alt
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 StringExpression
;--     load_rr_string
        MOVE    #Cstr_39, RR
;;;                                                                               } 39 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = false
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = char (20000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = pad
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 NumericExpression (constant 32 = 0x20)
;--     load_rr_constant
        MOVE    #0x0020, RR
;;;                                                                                 } 40 NumericExpression (constant 32 = 0x20)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                 { 40 Expr (l , r)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = char (20000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = sign
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                   } 41 NumericExpression (constant 0 = 0x0)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                   { 41 Expr (l , r)
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = false
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = char (20000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = flags
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr l & r
;;;                                                                                       { 43 TypeName (internal)
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                       } 43 TypeName (internal)
;;;                                                                                       { 43 Expression (variable name)
;;;                                                                                         expr_type = "identifier" (flags)
;--     load_rr_var flags = -6(FP), SP at -37 (8 bit)
        MOVE    31(SP), RS
;;;                                                                                       } 43 Expression (variable name)
;--     l & r
        AND     RR, #0x0002
;;;                                                                                     } 42 Expr l & r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = false
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = const char (20100)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = buffer
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr * r
;;;                                                                                       { 43 Expr l - r
;;;                                                                                         { 44 Expr ++r
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -38 (16 bit)
        MOVE    36(SP), RR
;;;                                                                                           } 45 Expression (variable name)
;--     ++
        ADD     RR, #0x0002
;--     store_rr_var args = -2(FP), SP at -38
        MOVE    RR, 36(SP)
;;;                                                                                         } 44 Expr ++r
;--     l - r
        SUB     RR, #0x0002
;;;                                                                                       } 43 Expr l - r
;--     content
        MOVE    (RR), RR
;;;                                                                                     } 42 Expr * r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                   } 41 Expr (l , r)
;;;                                                                                 } 40 Expr (l , r)
;;;                                                                               } 39 Expr (l , r)
;;;                                                                             } 38 Expr (l , r)
;;;                                                                           } 37 Expr (l , r)
;;;                                                                         } 36 Expr (l , r)
;;;                                                                       } 35 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprint_item
;--     pop 12 bytes
        ADD     SP, #12
;;;                                                                     } 34 Expr l(r)
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                                     } 34 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                   } 33 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                                 } 32 Expr l += r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0075:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l(r)
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = void (10000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = print_unsigned
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr (l , r)
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = value
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 Expression (cast)r
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expr l - r
;;;                                                                           { 37 Expr ++r
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -28 (16 bit)
        MOVE    26(SP), RR
;;;                                                                             } 38 Expression (variable name)
;--     ++
        ADD     RR, #0x0002
;--     store_rr_var args = -2(FP), SP at -28
        MOVE    RR, 26(SP)
;;;                                                                           } 37 Expr ++r
;--     l - r
        SUB     RR, #0x0002
;;;                                                                         } 36 Expr l - r
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;;;                                                                     } 34 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = char (20000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = dest
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -30
        LEA     2(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   } 33 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_unsigned
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                 } 32 Expr l(r)
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l += r
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = len
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 Expr l + r
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = print_item
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = min_p
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 48 = 0x30)
;--     load_rr_constant
        MOVE    #0x0030, RR
;;;                                                                       } 35 NumericExpression (constant 48 = 0x30)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = int (80000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = min_w
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (min_w)
;--     load_rr_var min_w = -14(FP), SP at -29 (16 bit)
        MOVE    15(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 Expr (l , r)
;;;                                                                           { 37 ParameterDeclaration
;;;                                                                             isEllipsis = false
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = field_w
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                           } 37 ParameterDeclaration
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (field_w)
;--     load_rr_var field_w = -12(FP), SP at -31 (16 bit)
        MOVE    19(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                           { 37 Expr (l , r)
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = false
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = const char (20100)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_POINTER
;;;                                                                                     { 42 List
;;;                                                                                       { 43 Ptr
;;;                                                                                       } 43 Ptr
;;;                                                                                     } 42 List
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = alt
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 StringExpression
;--     load_rr_string
        MOVE    #Cstr_40, RR
;;;                                                                             } 38 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = false
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = char (20000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = pad
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (pad)
;--     load_rr_var pad = -8(FP), SP at -35 (8 bit)
        MOVE    27(SP), RS
;;;                                                                               } 39 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = false
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = char (20000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = sign
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (sign)
;--     load_rr_var sign = -7(FP), SP at -36 (8 bit)
        MOVE    29(SP), RS
;;;                                                                                 } 40 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                 { 40 Expr (l , r)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = char (20000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = flags
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (flags)
;--     load_rr_var flags = -6(FP), SP at -37 (8 bit)
        MOVE    31(SP), RS
;;;                                                                                   } 41 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = const char (20100)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_POINTER
;;;                                                                                           { 45 List
;;;                                                                                             { 46 Ptr
;;;                                                                                             } 46 Ptr
;;;                                                                                           } 45 List
;;;                                                                                         } 44 DeclItem
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = buffer
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -38
        LEA     10(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 } 40 Expr (l , r)
;;;                                                                               } 39 Expr (l , r)
;;;                                                                             } 38 Expr (l , r)
;;;                                                                           } 37 Expr (l , r)
;;;                                                                         } 36 Expr (l , r)
;;;                                                                       } 35 Expr (l , r)
;;;                                                                     } 34 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprint_item
;--     pop 12 bytes
        ADD     SP, #12
;;;                                                                   } 33 Expr l(r)
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                                   } 33 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                 } 32 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                               } 31 Expr l += r
;;;                                                             } 30 ExpressionStatement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0078:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l(r)
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = void (10000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = print_hex
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr (l , r)
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = const char (20100)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = hex
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 StringExpression
;--     load_rr_string
        MOVE    #Cstr_41, RR
;;;                                                                     } 34 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = unsigned int (82000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = value
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 Expression (cast)r
;;;                                                                         { 36 Expr * r
;;;                                                                           { 37 Expr l - r
;;;                                                                             { 38 Expr ++r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -30 (16 bit)
        MOVE    28(SP), RR
;;;                                                                               } 39 Expression (variable name)
;--     ++
        ADD     RR, #0x0002
;--     store_rr_var args = -2(FP), SP at -30
        MOVE    RR, 28(SP)
;;;                                                                             } 38 Expr ++r
;--     l - r
        SUB     RR, #0x0002
;;;                                                                           } 37 Expr l - r
;--     content
        MOVE    (RR), RR
;;;                                                                         } 36 Expr * r
;;;                                                                       } 35 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = dest
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -32
        LEA     4(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                     } 34 Expr (l , r)
;;;                                                                   } 33 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_hex
;--     pop 6 bytes
        ADD     SP, #6
;;;                                                                 } 32 Expr l(r)
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l += r
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = len
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 Expr l + r
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = print_item
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = min_p
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 48 = 0x30)
;--     load_rr_constant
        MOVE    #0x0030, RR
;;;                                                                       } 35 NumericExpression (constant 48 = 0x30)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = int (80000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = min_w
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (min_w)
;--     load_rr_var min_w = -14(FP), SP at -29 (16 bit)
        MOVE    15(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 Expr (l , r)
;;;                                                                           { 37 ParameterDeclaration
;;;                                                                             isEllipsis = false
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = field_w
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                           } 37 ParameterDeclaration
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (field_w)
;--     load_rr_var field_w = -12(FP), SP at -31 (16 bit)
        MOVE    19(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                           { 37 Expr (l , r)
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = false
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = const char (20100)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_POINTER
;;;                                                                                     { 42 List
;;;                                                                                       { 43 Ptr
;;;                                                                                       } 43 Ptr
;;;                                                                                     } 42 List
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = alt
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 StringExpression
;--     load_rr_string
        MOVE    #Cstr_42, RR
;;;                                                                             } 38 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = false
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = char (20000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = pad
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (pad)
;--     load_rr_var pad = -8(FP), SP at -35 (8 bit)
        MOVE    27(SP), RS
;;;                                                                               } 39 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = false
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = char (20000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = sign
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (sign)
;--     load_rr_var sign = -7(FP), SP at -36 (8 bit)
        MOVE    29(SP), RS
;;;                                                                                 } 40 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                 { 40 Expr (l , r)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = char (20000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = flags
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (flags)
;--     load_rr_var flags = -6(FP), SP at -37 (8 bit)
        MOVE    31(SP), RS
;;;                                                                                   } 41 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = false
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = const char (20100)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_POINTER
;;;                                                                                           { 45 List
;;;                                                                                             { 46 Ptr
;;;                                                                                             } 46 Ptr
;;;                                                                                           } 45 List
;;;                                                                                         } 44 DeclItem
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = buffer
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;--     load_address buffer = -28(FP), SP at -38
        LEA     10(SP), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 } 40 Expr (l , r)
;;;                                                                               } 39 Expr (l , r)
;;;                                                                             } 38 Expr (l , r)
;;;                                                                           } 37 Expr (l , r)
;;;                                                                         } 36 Expr (l , r)
;;;                                                                       } 35 Expr (l , r)
;;;                                                                     } 34 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprint_item
;--     pop 12 bytes
        ADD     SP, #12
;;;                                                                   } 33 Expr l(r)
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                                   } 33 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                 } 32 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                               } 31 Expr l += r
;;;                                                             } 30 ExpressionStatement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0063:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l += r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = int (80000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = len
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = putchr
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = c
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 Expression (cast)r
;;;                                                                         { 36 Expr * r
;;;                                                                           { 37 Expr l - r
;;;                                                                             { 38 Expr ++r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -28 (16 bit)
        MOVE    26(SP), RR
;;;                                                                               } 39 Expression (variable name)
;--     ++
        ADD     RR, #0x0002
;--     store_rr_var args = -2(FP), SP at -28
        MOVE    RR, 26(SP)
;;;                                                                             } 38 Expr ++r
;--     l - r
        SUB     RR, #0x0002
;;;                                                                           } 37 Expr l - r
;--     content
        MOVE    (RR), RR
;;;                                                                         } 36 Expr * r
;;;                                                                       } 35 Expression (cast)r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                     } 34 Expr l(r)
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                                     } 34 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                   } 33 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                                 } 32 Expr l += r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0023:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l | r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = char (20000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = flags
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l | r
;;;                                                                     { 34 TypeName (internal)
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                     } 34 TypeName (internal)
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (flags)
;--     load_rr_var flags = -6(FP), SP at -28 (8 bit)
        MOVE    22(SP), RS
;;;                                                                     } 34 Expression (variable name)
;--     l | r
        OR      RR, #0x0001
;;;                                                                   } 33 Expr l | r
;--     store_rr_var flags = -6(FP), SP at -28
        MOVE    R, 22(SP)
;;;                                                                 } 32 Expr l | r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_002D:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l | r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = char (20000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = flags
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l | r
;;;                                                                     { 34 TypeName (internal)
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                     } 34 TypeName (internal)
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (flags)
;--     load_rr_var flags = -6(FP), SP at -28 (8 bit)
        MOVE    22(SP), RS
;;;                                                                     } 34 Expression (variable name)
;--     l | r
        OR      RR, #0x0002
;;;                                                                   } 33 Expr l | r
;--     store_rr_var flags = -6(FP), SP at -28
        MOVE    R, 22(SP)
;;;                                                                 } 32 Expr l | r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0020:
;;;                                                               { 31 IfElseStatement
;;;                                                                 { 32 Expr ! r
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (sign)
;--     load_rr_var sign = -7(FP), SP at -28 (8 bit)
        MOVE    21(SP), RS
;;;                                                                   } 33 Expression (variable name)
;--     16 bit ! r
        LNOT    RR
;;;                                                                 } 32 Expr ! r
;--     branch_false
        JMP     RRZ, L20_endif_62
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l = r
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = char (20000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = sign
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 NumericExpression (constant 32 = 0x20)
;--     load_rr_constant
        MOVE    #0x0020, RR
;;;                                                                     } 34 NumericExpression (constant 32 = 0x20)
;--     store_rr_var sign = -7(FP), SP at -28
        MOVE    R, 21(SP)
;;;                                                                   } 33 Expr l = r
;;;                                                                 } 32 ExpressionStatement
L20_endif_62:
;;;                                                               } 31 IfElseStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_002B:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = char (20000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = sign
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 NumericExpression (constant 43 = 0x2B)
;--     load_rr_constant
        MOVE    #0x002B, RR
;;;                                                                   } 33 NumericExpression (constant 43 = 0x2B)
;--     store_rr_var sign = -7(FP), SP at -28
        MOVE    R, 21(SP)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_002E:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_POINTER
;;;                                                                         { 36 List
;;;                                                                           { 37 Ptr
;;;                                                                           } 37 Ptr
;;;                                                                         } 36 List
;;;                                                                       } 35 DeclItem
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr & r
;--     load_address min_w = -14(FP), SP at -28
        LEA     14(SP), RR
;;;                                                                   } 33 Expr & r
;--     store_rr_var which_w = -16(FP), SP at -28
        MOVE    RR, 12(SP)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0030:
;;;                                                               { 31 IfElseStatement
;;;                                                                 { 32 Expr * r
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                   } 33 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                 } 32 Expr * r
;--     branch_false
        JMP     RRZ, L20_else_63
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l *- r
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = unsigned int (82000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = which_w
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                     { 34 Expr * r
;;;                                                                       { 35 Expression (variable name)
;;;                                                                         expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                       } 35 Expression (variable name)
;;;                                                                     } 34 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                   } 33 Expr l *- r
;;;                                                                 } 32 ExpressionStatement
;--     branch
        JMP     L20_endif_63
L20_else_63:
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l = r
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = char (20000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = pad
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 NumericExpression (constant 48 = 0x30)
;--     load_rr_constant
        MOVE    #0x0030, RR
;;;                                                                     } 34 NumericExpression (constant 48 = 0x30)
;--     store_rr_var pad = -8(FP), SP at -28
        MOVE    R, 20(SP)
;;;                                                                   } 33 Expr l = r
;;;                                                                 } 32 ExpressionStatement
L20_endif_63:
;;;                                                               } 31 IfElseStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0031:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0001
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0032:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0002
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0033:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0003
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0034:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0004
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0035:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0005
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0036:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0006
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0037:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0007
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0038:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0008
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0039:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l * r
;;;                                                                       { 35 TypeName (internal)
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = unsigned int (82000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                       } 35 TypeName (internal)
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -28 (16 bit)
        MOVE    12(SP), RR
;;;                                                                         } 36 Expression (variable name)
;--     content
        MOVE    (RR), RR
;;;                                                                       } 35 Expr * r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x000A, RR
;--     l * r
        DI
        MUL_IU
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                     } 34 Expr l * r
;--     l + r
        ADD     RR, #0x0009
;;;                                                                   } 33 Expr l + r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_002A:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l = r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = unsigned int (82000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = which_w
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expression (cast)r
;;;                                                                     { 34 Expr * r
;;;                                                                       { 35 Expr l - r
;;;                                                                         { 36 Expr ++r
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (args)
;--     load_rr_var args = -2(FP), SP at -28 (16 bit)
        MOVE    26(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     ++
        ADD     RR, #0x0002
;--     store_rr_var args = -2(FP), SP at -28
        MOVE    RR, 26(SP)
;;;                                                                         } 36 Expr ++r
;--     l - r
        SUB     RR, #0x0002
;;;                                                                       } 35 Expr l - r
;--     content
        MOVE    (RR), RR
;;;                                                                     } 34 Expr * r
;;;                                                                   } 33 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (which_w)
;--     load_rr_var which_w = -16(FP), SP at -30 (16 bit)
        MOVE    14(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     assign (16 bit)
        MOVE    RR, (LL)
;;;                                                                 } 32 Expr l = r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_cont_58
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_case_60_0000:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l + r
;;;                                                                   { 33 Expr --r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (format)
;--     load_rr_var format = 2(FP), SP at -28 (16 bit)
        MOVE    30(SP), RR
;;;                                                                     } 34 Expression (variable name)
;--     --
        SUB     RR, #0x0001
;--     store_rr_var format = 2(FP), SP at -28
        MOVE    RR, 30(SP)
;;;                                                                   } 33 Expr --r
;--     l + r
        ADD     RR, #0x0001
;;;                                                                 } 32 Expr l + r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                             { 30 case Statement
L20_deflt_60:
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l += r
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = int (80000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = len
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 Expr l + r
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = putchr
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = c
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 Expression (variable name)
;;;                                                                         expr_type = "identifier" (c)
;--     load_rr_var c = -5(FP), SP at -28 (8 bit)
        MOVE    23(SP), RS
;;;                                                                       } 35 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                     } 34 Expr l(r)
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (len)
;--     load_ll_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), LL
;;;                                                                     } 34 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                   } 33 Expr l + r
;--     store_rr_var len = -4(FP), SP at -28
        MOVE    RR, 24(SP)
;;;                                                                 } 32 Expr l += r
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 case Statement
;;;                                                             { 30 break/continue Statement
;--     branch
        JMP     L20_brk_60
;;;                                                             } 30 break/continue Statement
;;;                                                           } 29 List
;--     pop 0 bytes
;;;                                                         } 28 CompoundStatement
L20_brk_60:
;;;                                                       } 27 SwitchStatement
;;;                                                       { 27 break/continue Statement
;--     branch
        JMP     L20_brk_59
;;;                                                       } 27 break/continue Statement
;;;                                                     } 26 List
;--     pop 0 bytes
;;;                                                   } 25 CompoundStatement
L20_cont_58:
;--     branch
        JMP     L20_loop_58
L20_brk_59:
;;;                                                 } 24 for Statement
;;;                                               } 23 List
;--     pop 0 bytes
;;;                                             } 22 CompoundStatement
L20_cont_55:
;;;                                             { 22 Expr l = r
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = char (20000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = c
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 Expr * r
;;;                                                 { 24 Expr l - r
;;;                                                   { 25 Expr ++r
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (format)
;--     load_rr_var format = 2(FP), SP at -28 (16 bit)
        MOVE    30(SP), RR
;;;                                                     } 26 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var format = 2(FP), SP at -28
        MOVE    RR, 30(SP)
;;;                                                   } 25 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                 } 24 Expr l - r
;--     content
        MOVE    (RR), RS
;;;                                               } 23 Expr * r
;--     store_rr_var c = -5(FP), SP at -28
        MOVE    R, 23(SP)
;;;                                             } 22 Expr l = r
;--     branch_true
        JMP     RRNZ, L20_loop_55
L20_brk_56:
;;;                                           } 21 while Statement
;;;                                           { 21 return Statement
;;;                                             { 22 Expression (variable name)
;;;                                               expr_type = "identifier" (len)
;--     load_rr_var len = -4(FP), SP at -28 (16 bit)
        MOVE    24(SP), RR
;;;                                             } 22 Expression (variable name)
;--     ret
        ADD     SP, #28
        RET
;;;                                           } 21 return Statement
;;;                                         } 20 List
;--     pop 28 bytes
        ADD     SP, #28
;;;                                       } 19 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                       { 19 FunctionDefinition
;;;                                         { 20 TypeName
;;;                                           { 21 TypeSpecifier (all)
;;;                                             spec = int (80000)
;;;                                           } 21 TypeSpecifier (all)
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = getchr
;;;                                             } 22 DeclItem
;;;                                           } 21 List
;;;                                         } 20 TypeName
;;;                                         { 20 List
;;;                                           { 21 DeclItem
;;;                                             what = DECL_NAME
;;;                                             name = getchr
;;;                                           } 21 DeclItem
;;;                                           { 21 DeclItem
;;;                                             what = DECL_FUN
;;;                                           } 21 DeclItem
;;;                                         } 20 List
Cgetchr:
;;;                                         { 20 CompoundStatement
;;;                                           { 21 InitDeclarator
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = c
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                           } 21 InitDeclarator
;;;                                           { 21 List
;;;                                             { 22 ExpressionStatement
;;;                                               { 23 Expr l(r)
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = void (10000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = P
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 ParameterDeclaration
;;;                                                   isEllipsis = false
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (struct/union)
;;;                                                       spec = struct '_semaphore' (800000)
;;;                                                       name = _semaphore
;;;                                                     } 26 TypeSpecifier (struct/union)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_POINTER
;;;                                                         { 28 List
;;;                                                           { 29 Ptr
;;;                                                           } 29 Ptr
;;;                                                         } 28 List
;;;                                                       } 27 DeclItem
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = sema
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                 } 24 ParameterDeclaration
;;;                                                 { 24 Expr & r
;--     load_address rx_sema
        MOVE    #Crx_sema, RR
;;;                                                 } 24 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                               } 23 Expr l(r)
;;;                                             } 22 ExpressionStatement
;;;                                             { 22 ExpressionStatement
;;;                                               { 23 Expr l = r
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = char (20000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = c
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 Expr l[r]
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = unsigned char (22000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = serial_in_buffer
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                   { 25 Expr l[r]
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (serial_in_get)
;--     load_rr_var serial_in_get, (8 bit)
        MOVE    (Cserial_in_get), RU
;;;                                                     } 26 Expression (variable name)
;--     scale_rr *1
;--     add_address serial_in_buffer
        ADD     RR, #Cserial_in_buffer
;;;                                                   } 25 Expr l[r]
;--     content
        MOVE    (RR), RU
;;;                                                 } 24 Expr l[r]
;--     store_rr_var c = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                               } 23 Expr l = r
;;;                                             } 22 ExpressionStatement
;;;                                             { 22 IfElseStatement
;;;                                               { 23 Expr l >= r
;;;                                                 { 24 TypeName (internal)
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = unsigned int (82000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                 } 24 TypeName (internal)
;;;                                                 { 24 Expr ++r
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (serial_in_get)
;--     load_rr_var serial_in_get, (8 bit)
        MOVE    (Cserial_in_get), RU
;;;                                                   } 25 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var serial_in_get
        MOVE    R, (Cserial_in_get)
;;;                                                 } 24 Expr ++r
;--     l >= r
        SHS     RR, #0x0010
;;;                                               } 23 Expr l >= r
;--     branch_false
        JMP     RRZ, L21_endif_64
;;;                                               { 23 ExpressionStatement
;;;                                                 { 24 Expr l = r
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = unsigned char (22000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = serial_in_get
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                   { 25 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                   } 25 NumericExpression (constant 0 = 0x0)
;--     store_rr_var serial_in_get
        MOVE    R, (Cserial_in_get)
;;;                                                 } 24 Expr l = r
;;;                                               } 23 ExpressionStatement
L21_endif_64:
;;;                                             } 22 IfElseStatement
;;;                                             { 22 return Statement
;;;                                               { 23 Expression (variable name)
;;;                                                 expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                               } 23 Expression (variable name)
;--     ret
        ADD     SP, #1
        RET
;;;                                             } 22 return Statement
;;;                                           } 21 List
;--     pop 1 bytes
        ADD     SP, #1
;;;                                         } 20 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                         { 20 FunctionDefinition
;;;                                           { 21 TypeName
;;;                                             { 22 TypeSpecifier (all)
;;;                                               spec = int (80000)
;;;                                             } 22 TypeSpecifier (all)
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = getchr_timed
;;;                                               } 23 DeclItem
;;;                                             } 22 List
;;;                                           } 21 TypeName
;;;                                           { 21 List
;;;                                             { 22 DeclItem
;;;                                               what = DECL_NAME
;;;                                               name = getchr_timed
;;;                                             } 22 DeclItem
;;;                                             { 22 DeclItem
;;;                                               what = DECL_FUN
;;;                                               { 23 List
;;;                                                 { 24 ParameterDeclaration
;;;                                                   isEllipsis = false
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = unsigned int (82000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = ticks
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                 } 24 ParameterDeclaration
;;;                                               } 23 List
;;;                                             } 22 DeclItem
;;;                                           } 21 List
Cgetchr_timed:
;;;                                           { 21 CompoundStatement
;;;                                             { 22 InitDeclarator
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = c
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                             } 22 InitDeclarator
;;;                                             { 22 List
;;;                                               { 23 ExpressionStatement
;;;                                                 { 24 Expr l = r
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = char (20000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = c
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                   { 25 Expr l(r)
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = char (20000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = P_timed
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 Expr (l , r)
;;;                                                       { 27 ParameterDeclaration
;;;                                                         isEllipsis = false
;;;                                                         { 28 TypeName
;;;                                                           { 29 TypeSpecifier (all)
;;;                                                             spec = unsigned int (82000)
;;;                                                           } 29 TypeSpecifier (all)
;;;                                                           { 29 List
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_NAME
;;;                                                               name = ticks
;;;                                                             } 30 DeclItem
;;;                                                           } 29 List
;;;                                                         } 28 TypeName
;;;                                                       } 27 ParameterDeclaration
;;;                                                       { 27 Expression (variable name)
;;;                                                         expr_type = "identifier" (ticks)
;--     load_rr_var ticks = 2(FP), SP at -1 (16 bit)
        MOVE    3(SP), RR
;;;                                                       } 27 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                       { 27 ParameterDeclaration
;;;                                                         isEllipsis = false
;;;                                                         { 28 TypeName
;;;                                                           { 29 TypeSpecifier (struct/union)
;;;                                                             spec = struct '_semaphore' (800000)
;;;                                                             name = _semaphore
;;;                                                           } 29 TypeSpecifier (struct/union)
;;;                                                           { 29 List
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_POINTER
;;;                                                               { 31 List
;;;                                                                 { 32 Ptr
;;;                                                                 } 32 Ptr
;;;                                                               } 31 List
;;;                                                             } 30 DeclItem
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_NAME
;;;                                                               name = sema
;;;                                                             } 30 DeclItem
;;;                                                           } 29 List
;;;                                                         } 28 TypeName
;;;                                                       } 27 ParameterDeclaration
;;;                                                       { 27 Expr & r
;--     load_address rx_sema
        MOVE    #Crx_sema, RR
;;;                                                       } 27 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                     } 26 Expr (l , r)
;--     push 1 bytes
;--     call
        CALL    CP_timed
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                   } 25 Expr l(r)
;--     store_rr_var c = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                 } 24 Expr l = r
;;;                                               } 23 ExpressionStatement
;;;                                               { 23 IfElseStatement
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                 } 24 Expression (variable name)
;--     branch_false
        JMP     RRZ, L22_endif_65
;;;                                                 { 24 return Statement
;;;                                                   { 25 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0xFFFF, RR
;;;                                                   } 25 NumericExpression (constant 1 = 0x1)
;--     ret
        ADD     SP, #1
        RET
;;;                                                 } 24 return Statement
L22_endif_65:
;;;                                               } 23 IfElseStatement
;;;                                               { 23 ExpressionStatement
;;;                                                 { 24 Expr l = r
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = char (20000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = c
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                   { 25 Expr l[r]
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = unsigned char (22000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = serial_in_buffer
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 Expr l[r]
;;;                                                       { 27 Expression (variable name)
;;;                                                         expr_type = "identifier" (serial_in_get)
;--     load_rr_var serial_in_get, (8 bit)
        MOVE    (Cserial_in_get), RU
;;;                                                       } 27 Expression (variable name)
;--     scale_rr *1
;--     add_address serial_in_buffer
        ADD     RR, #Cserial_in_buffer
;;;                                                     } 26 Expr l[r]
;--     content
        MOVE    (RR), RU
;;;                                                   } 25 Expr l[r]
;--     store_rr_var c = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                 } 24 Expr l = r
;;;                                               } 23 ExpressionStatement
;;;                                               { 23 IfElseStatement
;;;                                                 { 24 Expr l >= r
;;;                                                   { 25 TypeName (internal)
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = unsigned int (82000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                   } 25 TypeName (internal)
;;;                                                   { 25 Expr ++r
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (serial_in_get)
;--     load_rr_var serial_in_get, (8 bit)
        MOVE    (Cserial_in_get), RU
;;;                                                     } 26 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var serial_in_get
        MOVE    R, (Cserial_in_get)
;;;                                                   } 25 Expr ++r
;--     l >= r
        SHS     RR, #0x0010
;;;                                                 } 24 Expr l >= r
;--     branch_false
        JMP     RRZ, L22_endif_66
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = unsigned char (22000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = serial_in_get
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                     } 26 NumericExpression (constant 0 = 0x0)
;--     store_rr_var serial_in_get
        MOVE    R, (Cserial_in_get)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
L22_endif_66:
;;;                                               } 23 IfElseStatement
;;;                                               { 23 return Statement
;;;                                                 { 24 Expression (variable name)
;;;                                                   expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                 } 24 Expression (variable name)
;--     ret
        ADD     SP, #1
        RET
;;;                                               } 23 return Statement
;;;                                             } 22 List
;--     pop 1 bytes
        ADD     SP, #1
;;;                                           } 21 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                           { 21 FunctionDefinition
;;;                                             { 22 TypeName
;;;                                               { 23 TypeSpecifier (all)
;;;                                                 spec = char (20000)
;;;                                               } 23 TypeSpecifier (all)
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = peekchr
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
;;;                                             } 22 TypeName
;;;                                             { 22 List
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_NAME
;;;                                                 name = peekchr
;;;                                               } 23 DeclItem
;;;                                               { 23 DeclItem
;;;                                                 what = DECL_FUN
;;;                                               } 23 DeclItem
;;;                                             } 22 List
Cpeekchr:
;;;                                             { 22 CompoundStatement
;;;                                               { 23 InitDeclarator
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = ret
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                               } 23 InitDeclarator
;;;                                               { 23 List
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l(r)
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = void (10000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = P
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 ParameterDeclaration
;;;                                                       isEllipsis = false
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (struct/union)
;;;                                                           spec = struct '_semaphore' (800000)
;;;                                                           name = _semaphore
;;;                                                         } 28 TypeSpecifier (struct/union)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_POINTER
;;;                                                             { 30 List
;;;                                                               { 31 Ptr
;;;                                                               } 31 Ptr
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = sema
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                     } 26 ParameterDeclaration
;;;                                                     { 26 Expr & r
;--     load_address rx_sema
        MOVE    #Crx_sema, RR
;;;                                                     } 26 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                   } 25 Expr l(r)
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l = r
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = char (20000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = ret
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 Expr l[r]
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (all)
;;;                                                           spec = unsigned char (22000)
;;;                                                         } 28 TypeSpecifier (all)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = serial_in_buffer
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                       { 27 Expr l[r]
;;;                                                         { 28 Expression (variable name)
;;;                                                           expr_type = "identifier" (serial_in_get)
;--     load_rr_var serial_in_get, (8 bit)
        MOVE    (Cserial_in_get), RU
;;;                                                         } 28 Expression (variable name)
;--     scale_rr *1
;--     add_address serial_in_buffer
        ADD     RR, #Cserial_in_buffer
;;;                                                       } 27 Expr l[r]
;--     content
        MOVE    (RR), RU
;;;                                                     } 26 Expr l[r]
;--     store_rr_var ret = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                   } 25 Expr l = r
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 ExpressionStatement
;;;                                                   { 25 Expr l(r)
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = void (10000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = V
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 ParameterDeclaration
;;;                                                       isEllipsis = false
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (struct/union)
;;;                                                           spec = struct '_semaphore' (800000)
;;;                                                           name = _semaphore
;;;                                                         } 28 TypeSpecifier (struct/union)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_POINTER
;;;                                                             { 30 List
;;;                                                               { 31 Ptr
;;;                                                               } 31 Ptr
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = sema
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                     } 26 ParameterDeclaration
;;;                                                     { 26 Expr & r
;--     load_address rx_sema
        MOVE    #Crx_sema, RR
;;;                                                     } 26 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                   } 25 Expr l(r)
;;;                                                 } 24 ExpressionStatement
;;;                                                 { 24 return Statement
;;;                                                   { 25 Expression (variable name)
;;;                                                     expr_type = "identifier" (ret)
;--     load_rr_var ret = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                   } 25 Expression (variable name)
;--     ret
        ADD     SP, #1
        RET
;;;                                                 } 24 return Statement
;;;                                               } 23 List
;--     pop 1 bytes
        ADD     SP, #1
;;;                                             } 22 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                             { 22 FunctionDefinition
;;;                                               { 23 TypeName
;;;                                                 { 24 TypeSpecifier (all)
;;;                                                   spec = char (20000)
;;;                                                 } 24 TypeSpecifier (all)
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = getnibble
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
;;;                                               } 23 TypeName
;;;                                               { 23 List
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_NAME
;;;                                                   name = getnibble
;;;                                                 } 24 DeclItem
;;;                                                 { 24 DeclItem
;;;                                                   what = DECL_FUN
;;;                                                   { 25 List
;;;                                                     { 26 ParameterDeclaration
;;;                                                       isEllipsis = false
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (all)
;;;                                                           spec = char (20000)
;;;                                                         } 28 TypeSpecifier (all)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = echo
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                     } 26 ParameterDeclaration
;;;                                                   } 25 List
;;;                                                 } 24 DeclItem
;;;                                               } 23 List
Cgetnibble:
;;;                                               { 23 CompoundStatement
;;;                                                 { 24 InitDeclarator
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = c
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                   { 25 Initializer (skalar)
;;;                                                     { 26 Expr l(r)
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (all)
;;;                                                           spec = char (20000)
;;;                                                         } 28 TypeSpecifier (all)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = peekchr
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;--     push 1 bytes
;--     call
        CALL    Cpeekchr
;--     pop 0 bytes
;;;                                                     } 26 Expr l(r)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                   } 25 Initializer (skalar)
;;;                                                 } 24 InitDeclarator
;;;                                                 { 24 InitDeclarator
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = ret
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                   { 25 Initializer (skalar)
;;;                                                     { 26 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0xFFFF, RR
;;;                                                     } 26 NumericExpression (constant 1 = 0x1)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                   } 25 Initializer (skalar)
;;;                                                 } 24 InitDeclarator
;;;                                                 { 24 List
;;;                                                   { 25 IfElseStatement
;;;                                                     { 26 Expr l && r
;;;                                                       { 27 TypeName (internal)
;;;                                                         { 28 TypeSpecifier (all)
;;;                                                           spec = int (80000)
;;;                                                         } 28 TypeSpecifier (all)
;;;                                                       } 27 TypeName (internal)
;;;                                                       { 27 IfElseStatement
;;;                                                         { 28 Expr l >= r
;;;                                                           { 29 TypeName (internal)
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = int (80000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                           } 29 TypeName (internal)
;;;                                                           { 29 Expression (variable name)
;;;                                                             expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                           } 29 Expression (variable name)
;--     l >= r
        SGE     RR, #0x0030
;;;                                                         } 28 Expr l >= r
;--     branch_false
        JMP     RRZ, L24_endif_68
;;;                                                         { 28 ExpressionStatement
;;;                                                           { 29 Expr l <= r
;;;                                                             { 30 TypeName (internal)
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = int (80000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                             } 30 TypeName (internal)
;;;                                                             { 30 Expression (variable name)
;;;                                                               expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                             } 30 Expression (variable name)
;--     l <= r
        SLE     RR, #0x0039
;;;                                                           } 29 Expr l <= r
;;;                                                         } 28 ExpressionStatement
L24_endif_68:
;;;                                                       } 27 IfElseStatement
;;;                                                     } 26 Expr l && r
;--     branch_false
        JMP     RRZ, L24_else_67
;;;                                                     { 26 ExpressionStatement
;;;                                                       { 27 Expr l = r
;;;                                                         { 28 TypeName
;;;                                                           { 29 TypeSpecifier (all)
;;;                                                             spec = int (80000)
;;;                                                           } 29 TypeSpecifier (all)
;;;                                                           { 29 List
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_NAME
;;;                                                               name = ret
;;;                                                             } 30 DeclItem
;;;                                                           } 29 List
;;;                                                         } 28 TypeName
;;;                                                         { 28 Expr l - r
;;;                                                           { 29 Expression (variable name)
;;;                                                             expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                           } 29 Expression (variable name)
;--     l - r
        SUB     RR, #0x0030
;;;                                                         } 28 Expr l - r
;--     store_rr_var ret = -3(FP), SP at -3
        MOVE    RR, 0(SP)
;;;                                                       } 27 Expr l = r
;;;                                                     } 26 ExpressionStatement
;--     branch
        JMP     L24_endif_67
L24_else_67:
;;;                                                     { 26 IfElseStatement
;;;                                                       { 27 Expr l && r
;;;                                                         { 28 TypeName (internal)
;;;                                                           { 29 TypeSpecifier (all)
;;;                                                             spec = int (80000)
;;;                                                           } 29 TypeSpecifier (all)
;;;                                                         } 28 TypeName (internal)
;;;                                                         { 28 IfElseStatement
;;;                                                           { 29 Expr l >= r
;;;                                                             { 30 TypeName (internal)
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = int (80000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                             } 30 TypeName (internal)
;;;                                                             { 30 Expression (variable name)
;;;                                                               expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                             } 30 Expression (variable name)
;--     l >= r
        SGE     RR, #0x0041
;;;                                                           } 29 Expr l >= r
;--     branch_false
        JMP     RRZ, L24_endif_70
;;;                                                           { 29 ExpressionStatement
;;;                                                             { 30 Expr l <= r
;;;                                                               { 31 TypeName (internal)
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = int (80000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                               } 31 TypeName (internal)
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                               } 31 Expression (variable name)
;--     l <= r
        SLE     RR, #0x0046
;;;                                                             } 30 Expr l <= r
;;;                                                           } 29 ExpressionStatement
L24_endif_70:
;;;                                                         } 28 IfElseStatement
;;;                                                       } 27 Expr l && r
;--     branch_false
        JMP     RRZ, L24_else_69
;;;                                                       { 27 ExpressionStatement
;;;                                                         { 28 Expr l = r
;;;                                                           { 29 TypeName
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = int (80000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = ret
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;;;                                                           } 29 TypeName
;;;                                                           { 29 Expr l - r
;;;                                                             { 30 Expression (variable name)
;;;                                                               expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                             } 30 Expression (variable name)
;--     l - r
        SUB     RR, #0x0037
;;;                                                           } 29 Expr l - r
;--     store_rr_var ret = -3(FP), SP at -3
        MOVE    RR, 0(SP)
;;;                                                         } 28 Expr l = r
;;;                                                       } 27 ExpressionStatement
;--     branch
        JMP     L24_endif_69
L24_else_69:
;;;                                                       { 27 IfElseStatement
;;;                                                         { 28 Expr l && r
;;;                                                           { 29 TypeName (internal)
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = int (80000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                           } 29 TypeName (internal)
;;;                                                           { 29 IfElseStatement
;;;                                                             { 30 Expr l >= r
;;;                                                               { 31 TypeName (internal)
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = int (80000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                               } 31 TypeName (internal)
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                               } 31 Expression (variable name)
;--     l >= r
        SGE     RR, #0x0061
;;;                                                             } 30 Expr l >= r
;--     branch_false
        JMP     RRZ, L24_endif_72
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l <= r
;;;                                                                 { 32 TypeName (internal)
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                 } 32 TypeName (internal)
;;;                                                                 { 32 Expression (variable name)
;;;                                                                   expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                                 } 32 Expression (variable name)
;--     l <= r
        SLE     RR, #0x0066
;;;                                                               } 31 Expr l <= r
;;;                                                             } 30 ExpressionStatement
L24_endif_72:
;;;                                                           } 29 IfElseStatement
;;;                                                         } 28 Expr l && r
;--     branch_false
        JMP     RRZ, L24_endif_71
;;;                                                         { 28 ExpressionStatement
;;;                                                           { 29 Expr l = r
;;;                                                             { 30 TypeName
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = int (80000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = ret
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                             } 30 TypeName
;;;                                                             { 30 Expr l - r
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                               } 31 Expression (variable name)
;--     l - r
        SUB     RR, #0x0057
;;;                                                             } 30 Expr l - r
;--     store_rr_var ret = -3(FP), SP at -3
        MOVE    RR, 0(SP)
;;;                                                           } 29 Expr l = r
;;;                                                         } 28 ExpressionStatement
L24_endif_71:
;;;                                                       } 27 IfElseStatement
L24_endif_69:
;;;                                                     } 26 IfElseStatement
L24_endif_67:
;;;                                                   } 25 IfElseStatement
;;;                                                   { 25 IfElseStatement
;;;                                                     { 26 Expr l != r
;;;                                                       { 27 TypeName (internal)
;;;                                                         { 28 TypeSpecifier (all)
;;;                                                           spec = int (80000)
;;;                                                         } 28 TypeSpecifier (all)
;;;                                                       } 27 TypeName (internal)
;;;                                                       { 27 Expression (variable name)
;;;                                                         expr_type = "identifier" (ret)
;--     load_rr_var ret = -3(FP), SP at -3 (16 bit)
        MOVE    0(SP), RR
;;;                                                       } 27 Expression (variable name)
;--     l != r
        SNE     RR, #0xFFFF
;;;                                                     } 26 Expr l != r
;--     branch_false
        JMP     RRZ, L24_endif_73
;;;                                                     { 26 CompoundStatement
;;;                                                       { 27 List
;;;                                                         { 28 ExpressionStatement
;;;                                                           { 29 Expr l(r)
;;;                                                             { 30 TypeName
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = int (80000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = getchr
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                             } 30 TypeName
;--     push 2 bytes
;--     call
        CALL    Cgetchr
;--     pop 0 bytes
;;;                                                           } 29 Expr l(r)
;;;                                                         } 28 ExpressionStatement
;;;                                                         { 28 IfElseStatement
;;;                                                           { 29 Expression (variable name)
;;;                                                             expr_type = "identifier" (echo)
;--     load_rr_var echo = 2(FP), SP at -3 (8 bit)
        MOVE    5(SP), RS
;;;                                                           } 29 Expression (variable name)
;--     branch_false
        JMP     RRZ, L24_endif_74
;;;                                                           { 29 ExpressionStatement
;;;                                                             { 30 Expr l(r)
;;;                                                               { 31 TypeName
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = int (80000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                                 { 32 List
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_NAME
;;;                                                                     name = putchr
;;;                                                                   } 33 DeclItem
;;;                                                                 } 32 List
;;;                                                               } 31 TypeName
;;;                                                               { 31 ParameterDeclaration
;;;                                                                 isEllipsis = false
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = char (20000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = c
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                               } 31 ParameterDeclaration
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -3 (8 bit)
        MOVE    2(SP), RS
;;;                                                               } 31 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                             } 30 Expr l(r)
;;;                                                           } 29 ExpressionStatement
L24_endif_74:
;;;                                                         } 28 IfElseStatement
;;;                                                       } 27 List
;--     pop 0 bytes
;;;                                                     } 26 CompoundStatement
L24_endif_73:
;;;                                                   } 25 IfElseStatement
;;;                                                   { 25 return Statement
;;;                                                     { 26 Expression (variable name)
;;;                                                       expr_type = "identifier" (ret)
;--     load_rr_var ret = -3(FP), SP at -3 (16 bit)
        MOVE    0(SP), RR
;;;                                                     } 26 Expression (variable name)
;--     ret
        ADD     SP, #3
        RET
;;;                                                   } 25 return Statement
;;;                                                 } 24 List
;--     pop 3 bytes
        ADD     SP, #3
;;;                                               } 23 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                               { 23 FunctionDefinition
;;;                                                 { 24 TypeName
;;;                                                   { 25 TypeSpecifier (all)
;;;                                                     spec = int (80000)
;;;                                                   } 25 TypeSpecifier (all)
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = gethex
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
;;;                                                 } 24 TypeName
;;;                                                 { 24 List
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_NAME
;;;                                                     name = gethex
;;;                                                   } 25 DeclItem
;;;                                                   { 25 DeclItem
;;;                                                     what = DECL_FUN
;;;                                                     { 26 List
;;;                                                       { 27 ParameterDeclaration
;;;                                                         isEllipsis = false
;;;                                                         { 28 TypeName
;;;                                                           { 29 TypeSpecifier (all)
;;;                                                             spec = char (20000)
;;;                                                           } 29 TypeSpecifier (all)
;;;                                                           { 29 List
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_NAME
;;;                                                               name = echo
;;;                                                             } 30 DeclItem
;;;                                                           } 29 List
;;;                                                         } 28 TypeName
;;;                                                       } 27 ParameterDeclaration
;;;                                                     } 26 List
;;;                                                   } 25 DeclItem
;;;                                                 } 24 List
Cgethex:
;;;                                                 { 24 CompoundStatement
;;;                                                   { 25 InitDeclarator
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = ret
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                     { 26 Initializer (skalar)
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                     } 26 Initializer (skalar)
;;;                                                   } 25 InitDeclarator
;;;                                                   { 25 InitDeclarator
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = c
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                                   } 25 InitDeclarator
;;;                                                   { 25 List
;;;                                                     { 26 while Statement
;--     branch
        JMP     L25_cont_75
L25_loop_75:
;;;                                                       { 27 ExpressionStatement
;;;                                                         { 28 Expr l = r
;;;                                                           { 29 TypeName
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = int (80000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = ret
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;;;                                                           } 29 TypeName
;;;                                                           { 29 Expr l | r
;;;                                                             { 30 TypeName (internal)
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = int (80000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                             } 30 TypeName (internal)
;;;                                                             { 30 Expr l << r
;;;                                                               { 31 TypeName (internal)
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = int (80000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                               } 31 TypeName (internal)
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (ret)
;--     load_rr_var ret = -2(FP), SP at -3 (16 bit)
        MOVE    1(SP), RR
;;;                                                               } 31 Expression (variable name)
;--     l << r
        LSL     RR, #0x0004
;;;                                                             } 30 Expr l << r
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                                             { 30 Expression (variable name)
;;;                                                               expr_type = "identifier" (c)
;--     load_rr_var c = -3(FP), SP at -3 (8 bit)
        MOVE    0(SP), RS
;;;                                                             } 30 Expression (variable name)
;--     l | r
        OR      LL, RR
;;;                                                           } 29 Expr l | r
;--     store_rr_var ret = -2(FP), SP at -3
        MOVE    RR, 1(SP)
;;;                                                         } 28 Expr l = r
;;;                                                       } 27 ExpressionStatement
L25_cont_75:
;;;                                                       { 27 Expr l != r
;;;                                                         { 28 TypeName (internal)
;;;                                                           { 29 TypeSpecifier (all)
;;;                                                             spec = int (80000)
;;;                                                           } 29 TypeSpecifier (all)
;;;                                                         } 28 TypeName (internal)
;;;                                                         { 28 Expr l = r
;;;                                                           { 29 TypeName
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = char (20000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = c
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;;;                                                           } 29 TypeName
;;;                                                           { 29 Expr l(r)
;;;                                                             { 30 TypeName
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = char (20000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = getnibble
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                             } 30 TypeName
;;;                                                             { 30 ParameterDeclaration
;;;                                                               isEllipsis = false
;;;                                                               { 31 TypeName
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = char (20000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                                 { 32 List
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_NAME
;;;                                                                     name = echo
;;;                                                                   } 33 DeclItem
;;;                                                                 } 32 List
;;;                                                               } 31 TypeName
;;;                                                             } 30 ParameterDeclaration
;;;                                                             { 30 Expression (variable name)
;;;                                                               expr_type = "identifier" (echo)
;--     load_rr_var echo = 2(FP), SP at -3 (8 bit)
        MOVE    5(SP), RS
;;;                                                             } 30 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 1 bytes
;--     call
        CALL    Cgetnibble
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                           } 29 Expr l(r)
;--     store_rr_var c = -3(FP), SP at -3
        MOVE    R, 0(SP)
;;;                                                         } 28 Expr l = r
;--     l != r
        SNE     RR, #0xFFFF
;;;                                                       } 27 Expr l != r
;--     branch_true
        JMP     RRNZ, L25_loop_75
L25_brk_76:
;;;                                                     } 26 while Statement
;;;                                                     { 26 return Statement
;;;                                                       { 27 Expression (variable name)
;;;                                                         expr_type = "identifier" (ret)
;--     load_rr_var ret = -2(FP), SP at -3 (16 bit)
        MOVE    1(SP), RR
;;;                                                       } 27 Expression (variable name)
;--     ret
        ADD     SP, #3
        RET
;;;                                                     } 26 return Statement
;;;                                                   } 25 List
;--     pop 3 bytes
        ADD     SP, #3
;;;                                                 } 24 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                 { 24 FunctionDefinition
;;;                                                   { 25 TypeName
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = void (10000)
;;;                                                     } 26 TypeSpecifier (all)
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = init_stack
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
;;;                                                   } 25 TypeName
;;;                                                   { 25 List
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_NAME
;;;                                                       name = init_stack
;;;                                                     } 26 DeclItem
;;;                                                     { 26 DeclItem
;;;                                                       what = DECL_FUN
;;;                                                     } 26 DeclItem
;;;                                                   } 25 List
Cinit_stack:
;;;                                                   { 25 CompoundStatement
;;;                                                     { 26 InitDeclarator
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_POINTER
;;;                                                           { 29 List
;;;                                                             { 30 Ptr
;;;                                                             } 30 Ptr
;;;                                                           } 29 List
;;;                                                         } 28 DeclItem
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = bottom
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                       { 27 Initializer (skalar)
;;;                                                         { 28 Expr * r
;;;                                                           { 29 Expression (variable name)
;;;                                                             expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                                                           } 29 Expression (variable name)
;;;                                                         } 28 Expr * r
;--     + (member)
        ADD     RR, #0x0008
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                       } 27 Initializer (skalar)
;;;                                                     } 26 InitDeclarator
;;;                                                     { 26 List
;;;                                                       { 27 while Statement
;--     branch
        JMP     L26_cont_77
L26_loop_77:
;;;                                                         { 28 ExpressionStatement
;;;                                                           { 29 Expr l = r
;;;                                                             { 30 TypeName
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = char (20000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = bottom
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                             } 30 TypeName
;;;                                                             { 30 NumericExpression (constant 83 = 0x53)
;--     load_rr_constant
        MOVE    #0x0053, RR
;;;                                                             } 30 NumericExpression (constant 83 = 0x53)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                             { 30 Expr * r
;;;                                                               { 31 Expr l - r
;;;                                                                 { 32 Expr ++r
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (bottom)
;--     load_rr_var bottom = -2(FP), SP at -3 (16 bit)
        MOVE    1(SP), RR
;;;                                                                   } 33 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var bottom = -2(FP), SP at -3
        MOVE    RR, 1(SP)
;;;                                                                 } 32 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                               } 31 Expr l - r
;;;                                                             } 30 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                                           } 29 Expr l = r
;;;                                                         } 28 ExpressionStatement
L26_cont_77:
;;;                                                         { 28 Expr l < r
;;;                                                           { 29 TypeName
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = char (20000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_POINTER
;;;                                                                 { 32 List
;;;                                                                   { 33 Ptr
;;;                                                                   } 33 Ptr
;;;                                                                 } 32 List
;;;                                                               } 31 DeclItem
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = bottom
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;;;                                                           } 29 TypeName
;;;                                                           { 29 Expression (cast)r
        LEA 0(SP), RR
;;;                                                           } 29 Expression (cast)r
;;;                                                           { 29 Expression (variable name)
;;;                                                             expr_type = "identifier" (bottom)
;--     load_ll_var bottom = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), LL
;;;                                                           } 29 Expression (variable name)
;--     l < r
        SLO     LL, RR
;;;                                                         } 28 Expr l < r
;--     branch_true
        JMP     RRNZ, L26_loop_77
L26_brk_78:
;;;                                                       } 27 while Statement
;;;                                                     } 26 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                   } 25 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                   { 25 Declaration
;;;                                                     { 26 TypeSpecifier (all)
;;;                                                       spec = extern char (20002)
;;;                                                     } 26 TypeSpecifier (all)
        .EXTERN Cend_text
;;;                                                   } 25 Declaration
;;; ------------------------------------;
;;;                                                   { 25 FunctionDefinition
;;;                                                     { 26 TypeName
;;;                                                       { 27 TypeSpecifier (all)
;;;                                                         spec = void (10000)
;;;                                                       } 27 TypeSpecifier (all)
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = init_unused
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
;;;                                                     } 26 TypeName
;;;                                                     { 26 List
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_NAME
;;;                                                         name = init_unused
;;;                                                       } 27 DeclItem
;;;                                                       { 27 DeclItem
;;;                                                         what = DECL_FUN
;;;                                                       } 27 DeclItem
;;;                                                     } 26 List
Cinit_unused:
;;;                                                     { 26 CompoundStatement
;;;                                                       { 27 InitDeclarator
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_POINTER
;;;                                                             { 30 List
;;;                                                               { 31 Ptr
;;;                                                               } 31 Ptr
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = cp
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                         { 28 Initializer (skalar)
;;;                                                           { 29 Expr * r
;;;                                                             { 30 Expression (variable name)
;;;                                                               expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                                                             } 30 Expression (variable name)
;;;                                                           } 29 Expr * r
;--     + (member)
        ADD     RR, #0x0008
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                         } 28 Initializer (skalar)
;;;                                                       } 27 InitDeclarator
;;;                                                       { 27 List
;;;                                                         { 28 while Statement
;--     branch
        JMP     L27_cont_79
L27_loop_79:
;;;                                                           { 29 ExpressionStatement
;;;                                                             { 30 Expr l = r
;;;                                                               { 31 TypeName
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = char (20000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                                 { 32 List
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_NAME
;;;                                                                     name = cp
;;;                                                                   } 33 DeclItem
;;;                                                                 } 32 List
;;;                                                               } 31 TypeName
;;;                                                               { 31 NumericExpression (constant 32 = 0x20)
;--     load_rr_constant
        MOVE    #0x0020, RR
;;;                                                               } 31 NumericExpression (constant 32 = 0x20)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                               { 31 Expr * r
;;;                                                                 { 32 Expression (variable name)
;;;                                                                   expr_type = "identifier" (cp)
;--     load_rr_var cp = -2(FP), SP at -3 (16 bit)
        MOVE    1(SP), RR
;;;                                                                 } 32 Expression (variable name)
;;;                                                               } 31 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RS
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                                             } 30 Expr l = r
;;;                                                           } 29 ExpressionStatement
L27_cont_79:
;;;                                                           { 29 Expr l >= r
;;;                                                             { 30 TypeName
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = char (20000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_POINTER
;;;                                                                   { 33 List
;;;                                                                     { 34 Ptr
;;;                                                                     } 34 Ptr
;;;                                                                   } 33 List
;;;                                                                 } 32 DeclItem
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = cp
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                             } 30 TypeName
;;;                                                             { 30 Expr --r
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (cp)
;--     load_rr_var cp = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                               } 31 Expression (variable name)
;--     --
        SUB     RR, #0x0001
;--     store_rr_var cp = -2(FP), SP at -2
        MOVE    RR, 0(SP)
;;;                                                             } 30 Expr --r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                             { 30 Expression (cast)r
;;;                                                               { 31 Expr & r
;--     load_address end_text
        MOVE    #Cend_text, RR
;;;                                                               } 31 Expr & r
;;;                                                             } 30 Expression (cast)r
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     l >= r
        SHS     LL, RR
;;;                                                           } 29 Expr l >= r
;--     branch_true
        JMP     RRNZ, L27_loop_79
L27_brk_80:
;;;                                                         } 28 while Statement
;;;                                                       } 27 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                     } 26 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                     { 26 FunctionDefinition
;;;                                                       { 27 TypeName
;;;                                                         { 28 TypeSpecifier (all)
;;;                                                           spec = int (80000)
;;;                                                         } 28 TypeSpecifier (all)
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = stack_used
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
;;;                                                       } 27 TypeName
;;;                                                       { 27 List
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_NAME
;;;                                                           name = stack_used
;;;                                                         } 28 DeclItem
;;;                                                         { 28 DeclItem
;;;                                                           what = DECL_FUN
;;;                                                           { 29 List
;;;                                                             { 30 ParameterDeclaration
;;;                                                               isEllipsis = false
;;;                                                               { 31 TypeName
;;;                                                                 { 32 TypeSpecifier (struct/union)
;;;                                                                   spec = struct '_task' (800000)
;;;                                                                   name = _task
;;;                                                                 } 32 TypeSpecifier (struct/union)
;;;                                                                 { 32 List
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_POINTER
;;;                                                                     { 34 List
;;;                                                                       { 35 Ptr
;;;                                                                       } 35 Ptr
;;;                                                                     } 34 List
;;;                                                                   } 33 DeclItem
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_NAME
;;;                                                                     name = t
;;;                                                                   } 33 DeclItem
;;;                                                                 } 32 List
;;;                                                               } 31 TypeName
;;;                                                             } 30 ParameterDeclaration
;;;                                                           } 29 List
;;;                                                         } 28 DeclItem
;;;                                                       } 27 List
Cstack_used:
;;;                                                       { 27 CompoundStatement
;;;                                                         { 28 InitDeclarator
;;;                                                           { 29 List
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_POINTER
;;;                                                               { 31 List
;;;                                                                 { 32 Ptr
;;;                                                                 } 32 Ptr
;;;                                                               } 31 List
;;;                                                             } 30 DeclItem
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_NAME
;;;                                                               name = bottom
;;;                                                             } 30 DeclItem
;;;                                                           } 29 List
;;;                                                           { 29 Initializer (skalar)
;;;                                                             { 30 Expr * r
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (t)
;--     load_rr_var t = 2(FP), SP at 0 (16 bit)
        MOVE    2(SP), RR
;;;                                                               } 31 Expression (variable name)
;;;                                                             } 30 Expr * r
;--     + (member)
        ADD     RR, #0x0008
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                           } 29 Initializer (skalar)
;;;                                                         } 28 InitDeclarator
;;;                                                         { 28 List
;;;                                                           { 29 while Statement
;--     branch
        JMP     L28_cont_81
L28_loop_81:
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l - r
;;;                                                                 { 32 Expr ++r
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (bottom)
;--     load_rr_var bottom = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                   } 33 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var bottom = -2(FP), SP at -2
        MOVE    RR, 0(SP)
;;;                                                                 } 32 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                               } 31 Expr l - r
;;;                                                             } 30 ExpressionStatement
L28_cont_81:
;;;                                                             { 30 Expr l == r
;;;                                                               { 31 TypeName (internal)
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = int (80000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                               } 31 TypeName (internal)
;;;                                                               { 31 Expr * r
;;;                                                                 { 32 Expression (variable name)
;;;                                                                   expr_type = "identifier" (bottom)
;--     load_rr_var bottom = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                 } 32 Expression (variable name)
;--     content
        MOVE    (RR), RS
;;;                                                               } 31 Expr * r
;--     l == r
        SEQ     RR, #0x0053
;;;                                                             } 30 Expr l == r
;--     branch_true
        JMP     RRNZ, L28_loop_81
L28_brk_82:
;;;                                                           } 29 while Statement
;;;                                                           { 29 return Statement
;;;                                                             { 30 Expr l - r
;;;                                                               { 31 Expr * r
;;;                                                                 { 32 Expression (variable name)
;;;                                                                   expr_type = "identifier" (t)
;--     load_rr_var t = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                                                 } 32 Expression (variable name)
;;;                                                               } 31 Expr * r
;--     + (member)
        ADD     RR, #0x000A
;--     content
        MOVE    (RR), RR
;--     move_rr_to_ll
        MOVE    RR, LL
;;;                                                               { 31 Expression (variable name)
;;;                                                                 expr_type = "identifier" (bottom)
;--     load_rr_var bottom = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                               } 31 Expression (variable name)
;--     scale_rr *1
;--     l - r
        SUB     LL, RR
;--     scale *1
;;;                                                             } 30 Expr l - r
;--     ret
        ADD     SP, #2
        RET
;;;                                                           } 29 return Statement
;;;                                                         } 28 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                       } 27 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                       { 27 FunctionDefinition
;;;                                                         { 28 TypeName
;;;                                                           { 29 TypeSpecifier (all)
;;;                                                             spec = void (10000)
;;;                                                           } 29 TypeSpecifier (all)
;;;                                                           { 29 List
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_NAME
;;;                                                               name = show_sema
;;;                                                             } 30 DeclItem
;;;                                                           } 29 List
;;;                                                         } 28 TypeName
;;;                                                         { 28 List
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_NAME
;;;                                                             name = show_sema
;;;                                                           } 29 DeclItem
;;;                                                           { 29 DeclItem
;;;                                                             what = DECL_FUN
;;;                                                             { 30 List
;;;                                                               { 31 ParameterDeclaration
;;;                                                                 isEllipsis = false
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (struct/union)
;;;                                                                     spec = struct '_semaphore' (800000)
;;;                                                                     name = _semaphore
;;;                                                                   } 33 TypeSpecifier (struct/union)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_POINTER
;;;                                                                       { 35 List
;;;                                                                         { 36 Ptr
;;;                                                                         } 36 Ptr
;;;                                                                       } 35 List
;;;                                                                     } 34 DeclItem
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = s
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                               } 31 ParameterDeclaration
;;;                                                             } 30 List
;;;                                                           } 29 DeclItem
;;;                                                         } 28 List
Cshow_sema:
;;;                                                         { 28 CompoundStatement
;;;                                                           { 29 InitDeclarator
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_POINTER
;;;                                                                 { 32 List
;;;                                                                   { 33 Ptr
;;;                                                                   } 33 Ptr
;;;                                                                 } 32 List
;;;                                                               } 31 DeclItem
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = t
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                           } 29 InitDeclarator
;;;                                                           { 29 List
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l(r)
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = printf
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 Expr (l , r)
;;;                                                                   { 33 ParameterDeclaration
;;;                                                                     isEllipsis = true
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = const char (20100)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_POINTER
;;;                                                                           { 37 List
;;;                                                                             { 38 Ptr
;;;                                                                             } 38 Ptr
;;;                                                                           } 37 List
;;;                                                                         } 36 DeclItem
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = format
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                   } 33 ParameterDeclaration
;;;                                                                   { 33 Expr * r
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (s)
;--     load_rr_var s = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                                                     } 34 Expression (variable name)
;;;                                                                   } 33 Expr * r
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   { 33 Expr (l , r)
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = true
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = const char (20100)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = format
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 Expr * r
;;;                                                                       { 35 Expression (variable name)
;;;                                                                         expr_type = "identifier" (s)
;--     load_rr_var s = 2(FP), SP at -4 (16 bit)
        MOVE    6(SP), RR
;;;                                                                       } 35 Expression (variable name)
;;;                                                                     } 34 Expr * r
;--     + (member)
        ADD     RR, #0x0006
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = true
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = const char (20100)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = format
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 StringExpression
;--     load_rr_string
        MOVE    #Cstr_44, RR
;;;                                                                     } 34 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   } 33 Expr (l , r)
;;;                                                                 } 32 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 6 bytes
        ADD     SP, #6
;;;                                                               } 31 Expr l(r)
;;;                                                             } 30 ExpressionStatement
;;;                                                             { 30 IfElseStatement
;;;                                                               { 31 Expr l < r
;;;                                                                 { 32 TypeName (internal)
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                 } 32 TypeName (internal)
;;;                                                                 { 32 Expr * r
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (s)
;--     load_rr_var s = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                                                   } 33 Expression (variable name)
;;;                                                                 } 32 Expr * r
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     l < r
        SLT     RR, #0x0000
;;;                                                               } 31 Expr l < r
;--     branch_false
        JMP     RRZ, L29_else_83
;;;                                                               { 31 CompoundStatement
;;;                                                                 { 32 List
;;;                                                                   { 33 for Statement
;;;                                                                     { 34 ExpressionStatement
;;;                                                                       { 35 Expr l = r
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (struct/union)
;;;                                                                             spec = struct '_task' (800000)
;;;                                                                             name = _task
;;;                                                                           } 37 TypeSpecifier (struct/union)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = t
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                         { 36 Expr * r
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (s)
;--     load_rr_var s = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                                                           } 37 Expression (variable name)
;;;                                                                         } 36 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     store_rr_var t = -2(FP), SP at -2
        MOVE    RR, 0(SP)
;;;                                                                       } 35 Expr l = r
;;;                                                                     } 34 ExpressionStatement
;--     branch
        JMP     L29_tst_84
L29_loop_84:
;;;                                                                     { 34 CompoundStatement
;;;                                                                       { 35 List
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l(r)
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = printf
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 Expr * r
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                 } 40 Expression (variable name)
;;;                                                                               } 39 Expr * r
;--     + (member)
        ADD     RR, #0x0006
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 StringExpression
;--     load_rr_string
        MOVE    #Cstr_45, RR
;;;                                                                               } 39 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             } 38 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                           } 37 Expr l(r)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 IfElseStatement
;;;                                                                           { 37 Expr l == r
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (struct/union)
;;;                                                                                 spec = struct '_task' (800000)
;;;                                                                                 name = _task
;;;                                                                               } 39 TypeSpecifier (struct/union)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_POINTER
;;;                                                                                   { 41 List
;;;                                                                                     { 42 Ptr
;;;                                                                                     } 42 Ptr
;;;                                                                                   } 41 List
;;;                                                                                 } 40 DeclItem
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = t
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                             { 38 Expr * r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (s)
;--     load_rr_var s = 2(FP), SP at -2 (16 bit)
        MOVE    4(SP), RR
;;;                                                                               } 39 Expression (variable name)
;;;                                                                             } 38 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RR
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (t)
;--     load_ll_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), LL
;;;                                                                             } 38 Expression (variable name)
;--     l == r
        SEQ     LL, RR
;;;                                                                           } 37 Expr l == r
;--     branch_false
        JMP     RRZ, L29_endif_86
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = printf
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 StringExpression
;--     load_rr_string
        MOVE    #Cstr_46, RR
;;;                                                                               } 39 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
L29_endif_86:
;;;                                                                         } 36 IfElseStatement
;;;                                                                       } 35 List
;--     pop 0 bytes
;;;                                                                     } 34 CompoundStatement
L29_cont_84:
;;;                                                                     { 34 Expr l = r
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (struct/union)
;;;                                                                           spec = struct '_task' (800000)
;;;                                                                           name = _task
;;;                                                                         } 36 TypeSpecifier (struct/union)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = t
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 Expr * r
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                         } 36 Expression (variable name)
;;;                                                                       } 35 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;--     store_rr_var t = -2(FP), SP at -2
        MOVE    RR, 0(SP)
;;;                                                                     } 34 Expr l = r
L29_tst_84:
;;;                                                                     { 34 Expression (variable name)
;;;                                                                       expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                     } 34 Expression (variable name)
;--     branch_true
        JMP     RRNZ, L29_loop_84
L29_brk_85:
;;;                                                                   } 33 for Statement
;;;                                                                 } 32 List
;--     pop 0 bytes
;;;                                                               } 31 CompoundStatement
;--     branch
        JMP     L29_endif_83
L29_else_83:
;;;                                                               { 31 CompoundStatement
;;;                                                                 { 32 List
;;;                                                                   { 33 ExpressionStatement
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = printf
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = true
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = const char (20100)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = format
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 StringExpression
;--     load_rr_string
        MOVE    #Cstr_47, RR
;;;                                                                       } 35 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                     } 34 Expr l(r)
;;;                                                                   } 33 ExpressionStatement
;;;                                                                 } 32 List
;--     pop 0 bytes
;;;                                                               } 31 CompoundStatement
L29_endif_83:
;;;                                                             } 30 IfElseStatement
;;;                                                             { 30 ExpressionStatement
;;;                                                               { 31 Expr l(r)
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = int (80000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = printf
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 ParameterDeclaration
;;;                                                                   isEllipsis = true
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = const char (20100)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_POINTER
;;;                                                                         { 36 List
;;;                                                                           { 37 Ptr
;;;                                                                           } 37 Ptr
;;;                                                                         } 36 List
;;;                                                                       } 35 DeclItem
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = format
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                 } 32 ParameterDeclaration
;;;                                                                 { 32 StringExpression
;--     load_rr_string
        MOVE    #Cstr_48, RR
;;;                                                                 } 32 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                               } 31 Expr l(r)
;;;                                                             } 30 ExpressionStatement
;;;                                                           } 29 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                         } 28 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                         { 28 Declaration
;;;                                                           { 29 TypeSpecifier (all)
;;;                                                             spec = unsigned char (22000)
;;;                                                           } 29 TypeSpecifier (all)
Cloader:                        ;
        .BYTE   46
        .BYTE   1
        .BYTE   17
        .BYTE   1
        .BYTE   61
        .BYTE   3
        .BYTE   50
        .BYTE   30
        .BYTE   46
        .BYTE   0
        .BYTE   7
        .BYTE   46
        .BYTE   1
        .BYTE   17
        .BYTE   2
        .BYTE   3
        .BYTE   61
        .BYTE   30
        .BYTE   101
        .BYTE   2
        .BYTE   47
        .BYTE   0
        .BYTE   7
        .BYTE   2
        .BYTE   89
        .BYTE   30
        .BYTE   97
        .BYTE   2
        .BYTE   161
        .BYTE   93
        .BYTE   2
        .BYTE   177
        .BYTE   71
        .BYTE   15
        .BYTE   5
        .BYTE   61
        .BYTE   30
        .BYTE   43
        .BYTE   1
        .BYTE   97
        .BYTE   2
        .BYTE   71
        .BYTE   3
        .BYTE   76
        .BYTE   30
        .BYTE   7
        .BYTE   5
        .BYTE   50
        .BYTE   30
        .BYTE   15
        .BYTE   101
        .BYTE   0
        .BYTE   41
        .BYTE   48
        .BYTE   4
        .BYTE   113
        .BYTE   30
        .BYTE   248
        .BYTE   255
        .BYTE   0
        .BYTE   2
        .BYTE   187
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   39
        .BYTE   57
        .BYTE   4
        .BYTE   127
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   247
        .BYTE   48
        .BYTE   2
        .BYTE   187
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   41
        .BYTE   65
        .BYTE   4
        .BYTE   140
        .BYTE   30
        .BYTE   248
        .BYTE   255
        .BYTE   0
        .BYTE   2
        .BYTE   187
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   39
        .BYTE   70
        .BYTE   4
        .BYTE   154
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   247
        .BYTE   55
        .BYTE   2
        .BYTE   187
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   41
        .BYTE   97
        .BYTE   4
        .BYTE   167
        .BYTE   30
        .BYTE   248
        .BYTE   255
        .BYTE   0
        .BYTE   2
        .BYTE   187
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   39
        .BYTE   102
        .BYTE   4
        .BYTE   181
        .BYTE   30
        .BYTE   101
        .BYTE   0
        .BYTE   247
        .BYTE   87
        .BYTE   2
        .BYTE   187
        .BYTE   30
        .BYTE   248
        .BYTE   255
        .BYTE   0
        .BYTE   2
        .BYTE   187
        .BYTE   30
        .BYTE   43
        .BYTE   1
        .BYTE   7
        .BYTE   5
        .BYTE   96
        .BYTE   30
        .BYTE   15
        .BYTE   45
        .BYTE   101
        .BYTE   1
        .BYTE   24
        .BYTE   255
        .BYTE   0
        .BYTE   4
        .BYTE   227
        .BYTE   30
        .BYTE   5
        .BYTE   96
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   101
        .BYTE   0
        .BYTE   24
        .BYTE   255
        .BYTE   0
        .BYTE   4
        .BYTE   227
        .BYTE   30
        .BYTE   101
        .BYTE   1
        .BYTE   82
        .BYTE   4
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   49
        .BYTE   2
        .BYTE   237
        .BYTE   30
        .BYTE   248
        .BYTE   199
        .BYTE   31
        .BYTE   14
        .BYTE   5
        .BYTE   73
        .BYTE   30
        .BYTE   43
        .BYTE   2
        .BYTE   0
        .BYTE   43
        .BYTE   2
        .BYTE   7
        .BYTE   45
        .BYTE   44
        .BYTE   45
        .BYTE   45
        .BYTE   45
        .BYTE   45
        .BYTE   248
        .BYTE   218
        .BYTE   31
        .BYTE   14
        .BYTE   5
        .BYTE   73
        .BYTE   30
        .BYTE   43
        .BYTE   2
        .BYTE   5
        .BYTE   50
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   25
        .BYTE   58
        .BYTE   3
        .BYTE   255
        .BYTE   30
        .BYTE   192
        .BYTE   95
        .BYTE   2
        .BYTE   5
        .BYTE   190
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   101
        .BYTE   2
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   88
        .BYTE   95
        .BYTE   2
        .BYTE   101
        .BYTE   0
        .BYTE   95
        .BYTE   6
        .BYTE   5
        .BYTE   190
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   101
        .BYTE   2
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   88
        .BYTE   95
        .BYTE   2
        .BYTE   101
        .BYTE   0
        .BYTE   82
        .BYTE   8
        .BYTE   93
        .BYTE   4
        .BYTE   5
        .BYTE   190
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   101
        .BYTE   2
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   88
        .BYTE   95
        .BYTE   2
        .BYTE   97
        .BYTE   4
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   49
        .BYTE   93
        .BYTE   4
        .BYTE   5
        .BYTE   190
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   101
        .BYTE   2
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   88
        .BYTE   95
        .BYTE   2
        .BYTE   101
        .BYTE   0
        .BYTE   95
        .BYTE   3
        .BYTE   192
        .BYTE   95
        .BYTE   1
        .BYTE   2
        .BYTE   124
        .BYTE   31
        .BYTE   5
        .BYTE   190
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   101
        .BYTE   0
        .BYTE   15
        .BYTE   101
        .BYTE   2
        .BYTE   14
        .BYTE   97
        .BYTE   7
        .BYTE   11
        .BYTE   88
        .BYTE   67
        .BYTE   9
        .BYTE   69
        .BYTE   101
        .BYTE   2
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   88
        .BYTE   95
        .BYTE   2
        .BYTE   101
        .BYTE   1
        .BYTE   161
        .BYTE   95
        .BYTE   1
        .BYTE   177
        .BYTE   101
        .BYTE   1
        .BYTE   67
        .BYTE   101
        .BYTE   6
        .BYTE   60
        .BYTE   3
        .BYTE   92
        .BYTE   31
        .BYTE   5
        .BYTE   190
        .BYTE   30
        .BYTE   95
        .BYTE   0
        .BYTE   101
        .BYTE   2
        .BYTE   67
        .BYTE   101
        .BYTE   0
        .BYTE   88
        .BYTE   95
        .BYTE   2
        .BYTE   101
        .BYTE   2
        .BYTE   4
        .BYTE   154
        .BYTE   31
        .BYTE   2
        .BYTE   184
        .BYTE   31
        .BYTE   249
        .BYTE   46
        .BYTE   15
        .BYTE   5
        .BYTE   61
        .BYTE   30
        .BYTE   43
        .BYTE   1
        .BYTE   101
        .BYTE   3
        .BYTE   23
        .BYTE   1
        .BYTE   4
        .BYTE   181
        .BYTE   31
        .BYTE   248
        .BYTE   228
        .BYTE   31
        .BYTE   14
        .BYTE   5
        .BYTE   73
        .BYTE   30
        .BYTE   43
        .BYTE   2
        .BYTE   97
        .BYTE   4
        .BYTE   6
        .BYTE   2
        .BYTE   255
        .BYTE   30
        .BYTE   248
        .BYTE   238
        .BYTE   31
        .BYTE   14
        .BYTE   5
        .BYTE   73
        .BYTE   30
        .BYTE   43
        .BYTE   2
        .BYTE   2
        .BYTE   246
        .BYTE   30
        .BYTE   43
        .BYTE   7
        .BYTE   7
        .BYTE   13
        .BYTE   10
        .BYTE   69
        .BYTE   82
        .BYTE   82
        .BYTE   79
        .BYTE   82
        .BYTE   58
        .BYTE   32
        .BYTE   110
        .BYTE   111
        .BYTE   116
        .BYTE   32
        .BYTE   104
        .BYTE   101
        .BYTE   120
        .BYTE   13
        .BYTE   10
        .BYTE   0
        .BYTE   13
        .BYTE   10
        .BYTE   76
        .BYTE   79
        .BYTE   65
        .BYTE   68
        .BYTE   32
        .BYTE   62
        .BYTE   32
        .BYTE   0
        .BYTE   13
        .BYTE   10
        .BYTE   68
        .BYTE   79
        .BYTE   78
        .BYTE   69
        .BYTE   46
        .BYTE   13
        .BYTE   10
        .BYTE   0
        .BYTE   13
        .BYTE   10
        .BYTE   67
        .BYTE   72
        .BYTE   69
        .BYTE   67
        .BYTE   75
        .BYTE   83
        .BYTE   85
        .BYTE   77
        .BYTE   32
        .BYTE   69
        .BYTE   82
        .BYTE   82
        .BYTE   79
        .BYTE   82
        .BYTE   46
        .BYTE   0
;;;                                                         } 28 Declaration
;;; ------------------------------------;
;;;                                                         { 28 FunctionDefinition
;;;                                                           { 29 TypeName
;;;                                                             { 30 TypeSpecifier (all)
;;;                                                               spec = void (10000)
;;;                                                             } 30 TypeSpecifier (all)
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = load_image
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
;;;                                                           } 29 TypeName
;;;                                                           { 29 List
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_NAME
;;;                                                               name = load_image
;;;                                                             } 30 DeclItem
;;;                                                             { 30 DeclItem
;;;                                                               what = DECL_FUN
;;;                                                             } 30 DeclItem
;;;                                                           } 29 List
Cload_image:
;;;                                                           { 29 CompoundStatement
;;;                                                             { 30 InitDeclarator
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_POINTER
;;;                                                                   { 33 List
;;;                                                                     { 34 Ptr
;;;                                                                     } 34 Ptr
;;;                                                                   } 33 List
;;;                                                                 } 32 DeclItem
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = from
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                               { 31 Initializer (skalar)
;;;                                                                 { 32 Expression (cast)r
;;;                                                                   { 33 Expr & r
;--     load_address loader
        MOVE    #Cloader, RR
;;;                                                                   } 33 Expr & r
;;;                                                                 } 32 Expression (cast)r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                               } 31 Initializer (skalar)
;;;                                                             } 30 InitDeclarator
;;;                                                             { 30 InitDeclarator
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_POINTER
;;;                                                                   { 33 List
;;;                                                                     { 34 Ptr
;;;                                                                     } 34 Ptr
;;;                                                                   } 33 List
;;;                                                                 } 32 DeclItem
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = to
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                               { 31 Initializer (skalar)
;;;                                                                 { 32 Expr l - r
;;;                                                                   { 33 Expression (cast)r
;;;                                                                     { 34 NumericExpression (constant 8192 = 0x2000)
;--     load_rr_constant
        MOVE    #0x2000, RR
;;;                                                                     } 34 NumericExpression (constant 8192 = 0x2000)
;;;                                                                   } 33 Expression (cast)r
;--     l - r
        SUB     RR, #0x01CE
;;;                                                                 } 32 Expr l - r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                               } 31 Initializer (skalar)
;;;                                                             } 30 InitDeclarator
;;;                                                             { 30 InitDeclarator
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = len
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                               { 31 Initializer (skalar)
;;;                                                                 { 32 NumericExpression (sizeof expr)
;--     load_rr_constant
        MOVE    #0x01CE, RR
;;;                                                                 } 32 NumericExpression (sizeof expr)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                               } 31 Initializer (skalar)
;;;                                                             } 30 InitDeclarator
;;;                                                             { 30 List
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expr l(r)
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = int (80000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = printf
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 ParameterDeclaration
;;;                                                                     isEllipsis = true
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = const char (20100)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_POINTER
;;;                                                                           { 37 List
;;;                                                                             { 38 Ptr
;;;                                                                             } 38 Ptr
;;;                                                                           } 37 List
;;;                                                                         } 36 DeclItem
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = format
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                   } 33 ParameterDeclaration
;;;                                                                   { 33 StringExpression
;--     load_rr_string
        MOVE    #Cstr_49, RR
;;;                                                                   } 33 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                 } 32 Expr l(r)
;;;                                                               } 31 ExpressionStatement
;;;                                                               { 31 while Statement
L30_loop_87:
;;;                                                                 { 32 ExpressionStatement
;;;                                                                 } 32 ExpressionStatement
L30_cont_87:
;;;                                                                 { 32 Expr l < r
;;;                                                                   { 33 TypeName (internal)
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = int (80000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                   } 33 TypeName (internal)
;--     load_address tx_sema
        MOVE    #Ctx_sema, RR
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     l < r
        SLT     RR, #0x0010
;;;                                                                 } 32 Expr l < r
;--     branch_true
        JMP     RRNZ, L30_loop_87
L30_brk_88:
;;;                                                               } 31 while Statement
;;;                                                               { 31 ExpressionStatement
        DI
;;;                                                               } 31 ExpressionStatement
;;;                                                               { 31 ExpressionStatement
        MOVE #0x00, RR
;;;                                                               } 31 ExpressionStatement
;;;                                                               { 31 ExpressionStatement
        OUT  R, (OUT_INT_MASK)
;;;                                                               } 31 ExpressionStatement
;;;                                                               { 31 for Statement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                 } 32 ExpressionStatement
;--     branch
        JMP     L30_tst_89
L30_loop_89:
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l = r
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = unsigned char (22000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = to
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr * r
;;;                                                                       { 35 Expr l - r
;;;                                                                         { 36 Expr ++r
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (from)
;--     load_rr_var from = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var from = -2(FP), SP at -6
        MOVE    RR, 4(SP)
;;;                                                                         } 36 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                       } 35 Expr l - r
;--     content
        MOVE    (RR), RU
;;;                                                                     } 34 Expr * r
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                     { 34 Expr * r
;;;                                                                       { 35 Expr l - r
;;;                                                                         { 36 Expr ++r
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (to)
;--     load_rr_var to = -4(FP), SP at -7 (16 bit)
        MOVE    3(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var to = -4(FP), SP at -7
        MOVE    RR, 3(SP)
;;;                                                                         } 36 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                       } 35 Expr l - r
;;;                                                                     } 34 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RU
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                                                   } 33 Expr l = r
;;;                                                                 } 32 ExpressionStatement
L30_cont_89:
;;;                                                                 { 32 Expr --r
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (len)
;--     load_rr_var len = -6(FP), SP at -6 (16 bit)
        MOVE    0(SP), RR
;;;                                                                   } 33 Expression (variable name)
;--     --
        SUB     RR, #0x0001
;--     store_rr_var len = -6(FP), SP at -6
        MOVE    RR, 0(SP)
;;;                                                                 } 32 Expr --r
L30_tst_89:
;;;                                                                 { 32 Expression (variable name)
;;;                                                                   expr_type = "identifier" (len)
;--     load_rr_var len = -6(FP), SP at -6 (16 bit)
        MOVE    0(SP), RR
;;;                                                                 } 32 Expression (variable name)
;--     branch_true
        JMP     RRNZ, L30_loop_89
L30_brk_90:
;;;                                                               } 31 for Statement
;;;                                                               { 31 ExpressionStatement
;;;                                                                 { 32 Expression (variable name)
;;;                                                                   expr_type = "identifier" (to)
;--     load_rr_var to = -4(FP), SP at -6 (16 bit)
        MOVE    2(SP), RR
;;;                                                                 } 32 Expression (variable name)
;;;                                                               } 31 ExpressionStatement
;;;                                                               { 31 ExpressionStatement
        MOVE  RR, SP
;;;                                                               } 31 ExpressionStatement
;;;                                                               { 31 ExpressionStatement
        JMP  0x1EF0             ; &main
;;;                                                               } 31 ExpressionStatement
;;;                                                             } 30 List
;--     pop 6 bytes
        ADD     SP, #6
;;;                                                           } 29 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                           { 29 FunctionDefinition
;;;                                                             { 30 TypeName
;;;                                                               { 31 TypeSpecifier (all)
;;;                                                                 spec = void (10000)
;;;                                                               } 31 TypeSpecifier (all)
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = show_semas
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
;;;                                                             } 30 TypeName
;;;                                                             { 30 List
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_NAME
;;;                                                                 name = show_semas
;;;                                                               } 31 DeclItem
;;;                                                               { 31 DeclItem
;;;                                                                 what = DECL_FUN
;;;                                                               } 31 DeclItem
;;;                                                             } 30 List
Cshow_semas:
;;;                                                             { 30 CompoundStatement
;;;                                                               { 31 List
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = printf
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = true
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = const char (20100)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = format
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 StringExpression
;--     load_rr_string
        MOVE    #Cstr_55, RR
;;;                                                                     } 34 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = void (10000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = print_n
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = int (80000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = count
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 79 = 0x4F)
;--     load_rr_constant
        MOVE    #0x004F, RR
;;;                                                                       } 35 NumericExpression (constant 79 = 0x4F)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = c
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 45 = 0x2D)
;--     load_rr_constant
        MOVE    #0x002D, RR
;;;                                                                       } 35 NumericExpression (constant 45 = 0x2D)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                     } 34 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_n
;--     pop 3 bytes
        ADD     SP, #3
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = printf
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = true
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = const char (20100)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = format
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 StringExpression
;--     load_rr_string
        MOVE    #Cstr_56, RR
;;;                                                                     } 34 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = void (10000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = show_sema
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (struct/union)
;;;                                                                           spec = struct '_semaphore' (800000)
;;;                                                                           name = _semaphore
;;;                                                                         } 36 TypeSpecifier (struct/union)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = s
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                     } 34 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cshow_sema
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = void (10000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = show_sema
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (struct/union)
;;;                                                                           spec = struct '_semaphore' (800000)
;;;                                                                           name = _semaphore
;;;                                                                         } 36 TypeSpecifier (struct/union)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = s
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 Expr & r
;--     load_address rx_sema
        MOVE    #Crx_sema, RR
;;;                                                                     } 34 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cshow_sema
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = void (10000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = show_sema
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (struct/union)
;;;                                                                           spec = struct '_semaphore' (800000)
;;;                                                                           name = _semaphore
;;;                                                                         } 36 TypeSpecifier (struct/union)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = s
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 Expr & r
;--     load_address tx_sema
        MOVE    #Ctx_sema, RR
;;;                                                                     } 34 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cshow_sema
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = void (10000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = show_sema
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (struct/union)
;;;                                                                           spec = struct '_semaphore' (800000)
;;;                                                                           name = _semaphore
;;;                                                                         } 36 TypeSpecifier (struct/union)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = s
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 Expr & r
;--     load_address t2_control
        MOVE    #Ct2_control, RR
;;;                                                                     } 34 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cshow_sema
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = void (10000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = show_sema
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = false
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (struct/union)
;;;                                                                           spec = struct '_semaphore' (800000)
;;;                                                                           name = _semaphore
;;;                                                                         } 36 TypeSpecifier (struct/union)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = s
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 Expr & r
;--     load_address t3_control
        MOVE    #Ct3_control, RR
;;;                                                                     } 34 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cshow_sema
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = void (10000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = print_n
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 Expr (l , r)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = int (80000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = count
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 79 = 0x4F)
;--     load_rr_constant
        MOVE    #0x004F, RR
;;;                                                                       } 35 NumericExpression (constant 79 = 0x4F)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = false
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = char (20000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = c
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 NumericExpression (constant 61 = 0x3D)
;--     load_rr_constant
        MOVE    #0x003D, RR
;;;                                                                       } 35 NumericExpression (constant 61 = 0x3D)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                     } 34 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_n
;--     pop 3 bytes
        ADD     SP, #3
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 ExpressionStatement
;;;                                                                   { 33 Expr l(r)
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = printf
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 ParameterDeclaration
;;;                                                                       isEllipsis = true
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = const char (20100)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = format
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                     } 34 ParameterDeclaration
;;;                                                                     { 34 StringExpression
;--     load_rr_string
        MOVE    #Cstr_57, RR
;;;                                                                     } 34 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                   } 33 Expr l(r)
;;;                                                                 } 32 ExpressionStatement
;;;                                                                 { 32 IfElseStatement
;;;                                                                   { 33 Expression (variable name)
;;;                                                                     expr_type = "identifier" (serial_in_overflows)
;--     load_rr_var serial_in_overflows, (16 bit)
        MOVE    (Cserial_in_overflows), RR
;;;                                                                   } 33 Expression (variable name)
;--     branch_false
        JMP     RRZ, L31_endif_91
;;;                                                                   { 33 ExpressionStatement
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = printf
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = true
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = const char (20100)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_POINTER
;;;                                                                                 { 40 List
;;;                                                                                   { 41 Ptr
;;;                                                                                   } 41 Ptr
;;;                                                                                 } 40 List
;;;                                                                               } 39 DeclItem
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = format
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 Expression (variable name)
;;;                                                                           expr_type = "identifier" (serial_in_overflows)
;--     load_rr_var serial_in_overflows, (16 bit)
        MOVE    (Cserial_in_overflows), RR
;;;                                                                         } 36 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = true
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = const char (20100)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_POINTER
;;;                                                                                 { 40 List
;;;                                                                                   { 41 Ptr
;;;                                                                                   } 41 Ptr
;;;                                                                                 } 40 List
;;;                                                                               } 39 DeclItem
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = format
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 StringExpression
;--     load_rr_string
        MOVE    #Cstr_58, RR
;;;                                                                         } 36 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                       } 35 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                     } 34 Expr l(r)
;;;                                                                   } 33 ExpressionStatement
L31_endif_91:
;;;                                                                 } 32 IfElseStatement
;;;                                                               } 31 List
;--     pop 0 bytes
;;;                                                             } 30 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                             { 30 FunctionDefinition
;;;                                                               { 31 TypeName
;;;                                                                 { 32 TypeSpecifier (all)
;;;                                                                   spec = void (10000)
;;;                                                                 } 32 TypeSpecifier (all)
;;;                                                                 { 32 List
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_NAME
;;;                                                                     name = show_tasks
;;;                                                                   } 33 DeclItem
;;;                                                                 } 32 List
;;;                                                               } 31 TypeName
;;;                                                               { 31 List
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_NAME
;;;                                                                   name = show_tasks
;;;                                                                 } 32 DeclItem
;;;                                                                 { 32 DeclItem
;;;                                                                   what = DECL_FUN
;;;                                                                 } 32 DeclItem
;;;                                                               } 31 List
Cshow_tasks:
;;;                                                               { 31 CompoundStatement
;;;                                                                 { 32 InitDeclarator
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_POINTER
;;;                                                                       { 35 List
;;;                                                                         { 36 Ptr
;;;                                                                         } 36 Ptr
;;;                                                                       } 35 List
;;;                                                                     } 34 DeclItem
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = t
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                   { 33 Initializer (skalar)
;;;                                                                     { 34 Expr & r
;--     load_address task_idle
        MOVE    #Ctask_idle, RR
;;;                                                                     } 34 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                   } 33 Initializer (skalar)
;;;                                                                 } 32 InitDeclarator
;;;                                                                 { 32 List
;;;                                                                   { 33 ExpressionStatement
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = printf
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = true
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = const char (20100)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = format
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 StringExpression
;--     load_rr_string
        MOVE    #Cstr_59, RR
;;;                                                                       } 35 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                     } 34 Expr l(r)
;;;                                                                   } 33 ExpressionStatement
;;;                                                                   { 33 ExpressionStatement
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = void (10000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = print_n
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = int (80000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = count
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 NumericExpression (constant 79 = 0x4F)
;--     load_rr_constant
        MOVE    #0x004F, RR
;;;                                                                         } 36 NumericExpression (constant 79 = 0x4F)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = char (20000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = c
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 NumericExpression (constant 45 = 0x2D)
;--     load_rr_constant
        MOVE    #0x002D, RR
;;;                                                                         } 36 NumericExpression (constant 45 = 0x2D)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                       } 35 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_n
;--     pop 3 bytes
        ADD     SP, #3
;;;                                                                     } 34 Expr l(r)
;;;                                                                   } 33 ExpressionStatement
;;;                                                                   { 33 ExpressionStatement
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = printf
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = true
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = const char (20100)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = format
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 StringExpression
;--     load_rr_string
        MOVE    #Cstr_61, RR
;;;                                                                       } 35 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                     } 34 Expr l(r)
;;;                                                                   } 33 ExpressionStatement
;;;                                                                   { 33 do while Statement
L32_loop_92:
;;;                                                                     { 34 CompoundStatement
;;;                                                                       { 35 List
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l(r)
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = printf
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 Expr l(r)
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = int (80000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = stack_used
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = false
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (struct/union)
;;;                                                                                       spec = struct '_task' (800000)
;;;                                                                                       name = _task
;;;                                                                                     } 42 TypeSpecifier (struct/union)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = t
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                 } 40 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cstack_used
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                               } 39 Expr l(r)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expr l - r
;;;                                                                                   { 41 Expr * r
;;;                                                                                     { 42 Expression (variable name)
;;;                                                                                       expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -4 (16 bit)
        MOVE    2(SP), RR
;;;                                                                                     } 42 Expression (variable name)
;;;                                                                                   } 41 Expr * r
;--     + (member)
        ADD     RR, #0x0008
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                   { 41 Expr * r
;;;                                                                                     { 42 Expression (variable name)
;;;                                                                                       expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                                                                     } 42 Expression (variable name)
;;;                                                                                   } 41 Expr * r
;--     + (member)
        ADD     RR, #0x000A
;--     content
        MOVE    (RR), RR
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (16 bit)
        MOVE    (SP)+, RR
;--     scale_rr *1
;--     l - r
        SUB     LL, RR
;--     scale *1
;;;                                                                                 } 40 Expr l - r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 { 40 Expr (l , r)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = true
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = const char (20100)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_POINTER
;;;                                                                                           { 45 List
;;;                                                                                             { 46 Ptr
;;;                                                                                             } 46 Ptr
;;;                                                                                           } 45 List
;;;                                                                                         } 44 DeclItem
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = format
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 Expr * r
;;;                                                                                     { 42 Expression (variable name)
;;;                                                                                       expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                                                                     } 42 Expression (variable name)
;;;                                                                                   } 41 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                   { 41 Expr (l , r)
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = true
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = const char (20100)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = format
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr l[r]
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = stack_pointer
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 Expr l[r]
;;;                                                                                         { 44 NumericExpression (constant 2 = 0x2)
;--     load_rr_constant
        MOVE    #0x0002, RR
;;;                                                                                         } 44 NumericExpression (constant 2 = 0x2)
;--     scale_rr *2
;--     *
        LSL     RR, #1
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                         { 44 Expr * r
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -10 (16 bit)
        MOVE    8(SP), RR
;;;                                                                                           } 45 Expression (variable name)
;;;                                                                                         } 44 Expr * r
;--     + (member)
        ADD     RR, #0x0002
;--     content
        MOVE    (RR), RR
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     + (element)
        ADD     LL, RR
;;;                                                                                       } 43 Expr l[r]
;--     content
        MOVE    (RR), RR
;;;                                                                                     } 42 Expr l[r]
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                     { 42 Expr (l , r)
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = true
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = const char (20100)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = format
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr * r
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -10 (16 bit)
        MOVE    8(SP), RR
;;;                                                                                         } 44 Expression (variable name)
;;;                                                                                       } 43 Expr * r
;--     + (member)
        ADD     RR, #0x0005
;--     content
        MOVE    (RR), RU
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                       { 43 Expr (l , r)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expr * r
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -12 (16 bit)
        MOVE    10(SP), RR
;;;                                                                                           } 45 Expression (variable name)
;;;                                                                                         } 44 Expr * r
;--     + (member)
        ADD     RR, #0x0006
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 StringExpression
;--     load_rr_string
        MOVE    #Cstr_62, RR
;;;                                                                                         } 44 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                       } 43 Expr (l , r)
;;;                                                                                     } 42 Expr (l , r)
;;;                                                                                   } 41 Expr (l , r)
;;;                                                                                 } 40 Expr (l , r)
;;;                                                                               } 39 Expr (l , r)
;;;                                                                             } 38 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 14 bytes
        ADD     SP, #14
;;;                                                                           } 37 Expr l(r)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 IfElseStatement
;;;                                                                           { 37 Expr * r
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                             } 38 Expression (variable name)
;;;                                                                           } 37 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;--     branch_false
        JMP     RRZ, L32_else_94
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = printf
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expr * r
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                   } 41 Expression (variable name)
;;;                                                                                 } 40 Expr * r
;--     + (member)
        ADD     RR, #0x0010
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 StringExpression
;--     load_rr_string
        MOVE    #Cstr_63, RR
;;;                                                                                 } 40 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                               } 39 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
;--     branch
        JMP     L32_endif_94
L32_else_94:
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = printf
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 StringExpression
;--     load_rr_string
        MOVE    #Cstr_64, RR
;;;                                                                               } 39 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
L32_endif_94:
;;;                                                                         } 36 IfElseStatement
;;;                                                                         { 36 IfElseStatement
;;;                                                                           { 37 Expr l == r
;;;                                                                             { 38 TypeName (internal)
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                             } 38 TypeName (internal)
;;;                                                                             { 38 Expr * r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                               } 39 Expression (variable name)
;;;                                                                             } 38 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l == r
        SEQ     RR, #0x0000
;;;                                                                           } 37 Expr l == r
;--     branch_false
        JMP     RRZ, L32_endif_95
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = printf
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 StringExpression
;--     load_rr_string
        MOVE    #Cstr_65, RR
;;;                                                                               } 39 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
L32_endif_95:
;;;                                                                         } 36 IfElseStatement
;;;                                                                         { 36 IfElseStatement
;;;                                                                           { 37 Expr l & r
;;;                                                                             { 38 TypeName (internal)
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                             } 38 TypeName (internal)
;;;                                                                             { 38 Expr * r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                               } 39 Expression (variable name)
;;;                                                                             } 38 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0x0004
;;;                                                                           } 37 Expr l & r
;--     branch_false
        JMP     RRZ, L32_endif_96
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = printf
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 StringExpression
;--     load_rr_string
        MOVE    #Cstr_66, RR
;;;                                                                               } 39 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
L32_endif_96:
;;;                                                                         } 36 IfElseStatement
;;;                                                                         { 36 IfElseStatement
;;;                                                                           { 37 Expr l & r
;;;                                                                             { 38 TypeName (internal)
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                             } 38 TypeName (internal)
;;;                                                                             { 38 Expr * r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                               } 39 Expression (variable name)
;;;                                                                             } 38 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0x0002
;;;                                                                           } 37 Expr l & r
;--     branch_false
        JMP     RRZ, L32_endif_97
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = printf
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expr * r
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                   } 41 Expression (variable name)
;;;                                                                                 } 40 Expr * r
;--     + (member)
        ADD     RR, #0x0012
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 StringExpression
;--     load_rr_string
        MOVE    #Cstr_67, RR
;;;                                                                                 } 40 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                               } 39 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
L32_endif_97:
;;;                                                                         } 36 IfElseStatement
;;;                                                                         { 36 IfElseStatement
;;;                                                                           { 37 Expr l & r
;;;                                                                             { 38 TypeName (internal)
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                             } 38 TypeName (internal)
;;;                                                                             { 38 Expr * r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                               } 39 Expression (variable name)
;;;                                                                             } 38 Expr * r
;--     + (member)
        ADD     RR, #0x0004
;--     content
        MOVE    (RR), RS
;--     l & r
        AND     RR, #0x0001
;;;                                                                           } 37 Expr l & r
;--     branch_false
        JMP     RRZ, L32_endif_98
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = printf
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 Expr (l , r)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 Expr * r
;;;                                                                                   { 41 Expr * r
;;;                                                                                     { 42 Expression (variable name)
;;;                                                                                       expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                     } 42 Expression (variable name)
;;;                                                                                   } 41 Expr * r
;--     + (member)
        ADD     RR, #0x000E
;--     content
        MOVE    (RR), RR
;;;                                                                                 } 40 Expr * r
;--     + (member)
        ADD     RR, #0x0006
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 StringExpression
;--     load_rr_string
        MOVE    #Cstr_68, RR
;;;                                                                                 } 40 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                               } 39 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
L32_endif_98:
;;;                                                                         } 36 IfElseStatement
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l(r)
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = printf
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = true
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = const char (20100)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_POINTER
;;;                                                                                     { 42 List
;;;                                                                                       { 43 Ptr
;;;                                                                                       } 43 Ptr
;;;                                                                                     } 42 List
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = format
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 StringExpression
;--     load_rr_string
        MOVE    #Cstr_69, RR
;;;                                                                             } 38 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                           } 37 Expr l(r)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l = r
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (struct/union)
;;;                                                                                 spec = struct '_task' (800000)
;;;                                                                                 name = _task
;;;                                                                               } 39 TypeSpecifier (struct/union)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_POINTER
;;;                                                                                   { 41 List
;;;                                                                                     { 42 Ptr
;;;                                                                                     } 42 Ptr
;;;                                                                                   } 41 List
;;;                                                                                 } 40 DeclItem
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = t
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                             { 38 Expr * r
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (t)
;--     load_rr_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                               } 39 Expression (variable name)
;;;                                                                             } 38 Expr * r
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     store_rr_var t = -2(FP), SP at -2
        MOVE    RR, 0(SP)
;;;                                                                           } 37 Expr l = r
;;;                                                                         } 36 ExpressionStatement
;;;                                                                       } 35 List
;--     pop 0 bytes
;;;                                                                     } 34 CompoundStatement
L32_cont_92:
;;;                                                                     { 34 Expr l != r
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (struct/union)
;;;                                                                           spec = struct '_task' (800000)
;;;                                                                           name = _task
;;;                                                                         } 36 TypeSpecifier (struct/union)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_POINTER
;;;                                                                             { 38 List
;;;                                                                               { 39 Ptr
;;;                                                                               } 39 Ptr
;;;                                                                             } 38 List
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = t
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 Expr & r
;--     load_address task_idle
        MOVE    #Ctask_idle, RR
;;;                                                                       } 35 Expr & r
;;;                                                                       { 35 Expression (variable name)
;;;                                                                         expr_type = "identifier" (t)
;--     load_ll_var t = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), LL
;;;                                                                       } 35 Expression (variable name)
;--     l != r
        SNE     LL, RR
;;;                                                                     } 34 Expr l != r
;--     branch_true
        JMP     RRNZ, L32_loop_92
L32_brk_93:
;;;                                                                   } 33 do while Statement
;;;                                                                   { 33 ExpressionStatement
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = void (10000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = print_n
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 Expr (l , r)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = int (80000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = count
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 NumericExpression (constant 79 = 0x4F)
;--     load_rr_constant
        MOVE    #0x004F, RR
;;;                                                                         } 36 NumericExpression (constant 79 = 0x4F)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = char (20000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = c
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                         { 36 NumericExpression (constant 61 = 0x3D)
;--     load_rr_constant
        MOVE    #0x003D, RR
;;;                                                                         } 36 NumericExpression (constant 61 = 0x3D)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                       } 35 Expr (l , r)
;--     push 0 bytes
;--     call
        CALL    Cprint_n
;--     pop 3 bytes
        ADD     SP, #3
;;;                                                                     } 34 Expr l(r)
;;;                                                                   } 33 ExpressionStatement
;;;                                                                   { 33 ExpressionStatement
;;;                                                                     { 34 Expr l(r)
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = printf
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 ParameterDeclaration
;;;                                                                         isEllipsis = true
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = const char (20100)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = format
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                       } 35 ParameterDeclaration
;;;                                                                       { 35 StringExpression
;--     load_rr_string
        MOVE    #Cstr_70, RR
;;;                                                                       } 35 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                     } 34 Expr l(r)
;;;                                                                   } 33 ExpressionStatement
;;;                                                                 } 32 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                               } 31 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                               { 31 FunctionDefinition
;;;                                                                 { 32 TypeName
;;;                                                                   { 33 TypeSpecifier (all)
;;;                                                                     spec = void (10000)
;;;                                                                   } 33 TypeSpecifier (all)
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = show_time
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
;;;                                                                 } 32 TypeName
;;;                                                                 { 32 List
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_NAME
;;;                                                                     name = show_time
;;;                                                                   } 33 DeclItem
;;;                                                                   { 33 DeclItem
;;;                                                                     what = DECL_FUN
;;;                                                                   } 33 DeclItem
;;;                                                                 } 32 List
Cshow_time:
;;;                                                                 { 32 CompoundStatement
;;;                                                                   { 33 InitDeclarator
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = sl
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                   } 33 InitDeclarator
;;;                                                                   { 33 InitDeclarator
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = sm
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                   } 33 InitDeclarator
;;;                                                                   { 33 InitDeclarator
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = sh
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                   } 33 InitDeclarator
;;;                                                                   { 33 List
;;;                                                                     { 34 do while Statement
L33_loop_99:
;;;                                                                       { 35 CompoundStatement
;;;                                                                         { 36 List
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l = r
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = unsigned char (22000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = seconds_changed
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                               } 39 NumericExpression (constant 0 = 0x0)
;--     store_rr_var seconds_changed
        MOVE    R, (Cseconds_changed)
;;;                                                                             } 38 Expr l = r
;;;                                                                           } 37 ExpressionStatement
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l = r
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = unsigned int (82000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = sl
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (seconds_low)
;--     load_rr_var seconds_low, (16 bit)
        MOVE    (Cseconds_low), RR
;;;                                                                               } 39 Expression (variable name)
;--     store_rr_var sl = -2(FP), SP at -6
        MOVE    RR, 4(SP)
;;;                                                                             } 38 Expr l = r
;;;                                                                           } 37 ExpressionStatement
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l = r
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = unsigned int (82000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = sm
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (seconds_mid)
;--     load_rr_var seconds_mid, (16 bit)
        MOVE    (Cseconds_mid), RR
;;;                                                                               } 39 Expression (variable name)
;--     store_rr_var sm = -4(FP), SP at -6
        MOVE    RR, 2(SP)
;;;                                                                             } 38 Expr l = r
;;;                                                                           } 37 ExpressionStatement
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l = r
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = unsigned int (82000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = sh
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (seconds_high)
;--     load_rr_var seconds_high, (16 bit)
        MOVE    (Cseconds_high), RR
;;;                                                                               } 39 Expression (variable name)
;--     store_rr_var sh = -6(FP), SP at -6
        MOVE    RR, 0(SP)
;;;                                                                             } 38 Expr l = r
;;;                                                                           } 37 ExpressionStatement
;;;                                                                         } 36 List
;--     pop 0 bytes
;;;                                                                       } 35 CompoundStatement
L33_cont_99:
;;;                                                                       { 35 Expression (variable name)
;;;                                                                         expr_type = "identifier" (seconds_changed)
;--     load_rr_var seconds_changed, (8 bit)
        MOVE    (Cseconds_changed), RU
;;;                                                                       } 35 Expression (variable name)
;--     branch_true
        JMP     RRNZ, L33_loop_99
L33_brk_100:
;;;                                                                     } 34 do while Statement
;;;                                                                     { 34 ExpressionStatement
;;;                                                                       { 35 Expr l(r)
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = int (80000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = printf
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                         { 36 Expr (l , r)
;;;                                                                           { 37 ParameterDeclaration
;;;                                                                             isEllipsis = true
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = const char (20100)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_POINTER
;;;                                                                                   { 41 List
;;;                                                                                     { 42 Ptr
;;;                                                                                     } 42 Ptr
;;;                                                                                   } 41 List
;;;                                                                                 } 40 DeclItem
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = format
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                           } 37 ParameterDeclaration
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (sl)
;--     load_rr_var sl = -2(FP), SP at -6 (16 bit)
        MOVE    4(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                           { 37 Expr (l , r)
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = true
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = const char (20100)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_POINTER
;;;                                                                                     { 42 List
;;;                                                                                       { 43 Ptr
;;;                                                                                       } 43 Ptr
;;;                                                                                     } 42 List
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = format
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (sm)
;--     load_rr_var sm = -4(FP), SP at -8 (16 bit)
        MOVE    4(SP), RR
;;;                                                                             } 38 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             { 38 Expr (l , r)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 Expression (variable name)
;;;                                                                                 expr_type = "identifier" (sh)
;--     load_rr_var sh = -6(FP), SP at -10 (16 bit)
        MOVE    4(SP), RR
;;;                                                                               } 39 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                               { 39 ParameterDeclaration
;;;                                                                                 isEllipsis = true
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = const char (20100)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = format
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                               } 39 ParameterDeclaration
;;;                                                                               { 39 StringExpression
;--     load_rr_string
        MOVE    #Cstr_71, RR
;;;                                                                               } 39 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                             } 38 Expr (l , r)
;;;                                                                           } 37 Expr (l , r)
;;;                                                                         } 36 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 8 bytes
        ADD     SP, #8
;;;                                                                       } 35 Expr l(r)
;;;                                                                     } 34 ExpressionStatement
;;;                                                                   } 33 List
;--     pop 6 bytes
        ADD     SP, #6
;;;                                                                 } 32 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                                 { 32 FunctionDefinition
;;;                                                                   { 33 TypeName
;;;                                                                     { 34 TypeSpecifier (all)
;;;                                                                       spec = void (10000)
;;;                                                                     } 34 TypeSpecifier (all)
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = display_memory
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
;;;                                                                   } 33 TypeName
;;;                                                                   { 33 List
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_NAME
;;;                                                                       name = display_memory
;;;                                                                     } 34 DeclItem
;;;                                                                     { 34 DeclItem
;;;                                                                       what = DECL_FUN
;;;                                                                       { 35 List
;;;                                                                         { 36 ParameterDeclaration
;;;                                                                           isEllipsis = false
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = unsigned char (22000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_POINTER
;;;                                                                                 { 40 List
;;;                                                                                   { 41 Ptr
;;;                                                                                   } 41 Ptr
;;;                                                                                 } 40 List
;;;                                                                               } 39 DeclItem
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = address
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                         } 36 ParameterDeclaration
;;;                                                                       } 35 List
;;;                                                                     } 34 DeclItem
;;;                                                                   } 33 List
Cdisplay_memory:
;;;                                                                   { 33 CompoundStatement
;;;                                                                     { 34 InitDeclarator
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = c
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                                                     } 34 InitDeclarator
;;;                                                                     { 34 InitDeclarator
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = row
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                     } 34 InitDeclarator
;;;                                                                     { 34 InitDeclarator
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = col
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                     } 34 InitDeclarator
;;;                                                                     { 34 List
;;;                                                                       { 35 for Statement
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l = r
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = row
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;;;                                                                             { 38 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                             } 38 NumericExpression (constant 0 = 0x0)
;--     store_rr_var row = -3(FP), SP at -5
        MOVE    RR, 2(SP)
;;;                                                                           } 37 Expr l = r
;;;                                                                         } 36 ExpressionStatement
;--     branch
        JMP     L34_tst_101
L34_loop_101:
;;;                                                                         { 36 CompoundStatement
;;;                                                                           { 37 List
;;;                                                                             { 38 ExpressionStatement
;;;                                                                               { 39 Expr l(r)
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = int (80000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = printf
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                                 { 40 Expr (l , r)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = true
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = const char (20100)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_POINTER
;;;                                                                                           { 45 List
;;;                                                                                             { 46 Ptr
;;;                                                                                             } 46 Ptr
;;;                                                                                           } 45 List
;;;                                                                                         } 44 DeclItem
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = format
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (address)
;--     load_rr_var address = 2(FP), SP at -5 (16 bit)
        MOVE    7(SP), RR
;;;                                                                                   } 41 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                   { 41 ParameterDeclaration
;;;                                                                                     isEllipsis = true
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = const char (20100)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_POINTER
;;;                                                                                           { 45 List
;;;                                                                                             { 46 Ptr
;;;                                                                                             } 46 Ptr
;;;                                                                                           } 45 List
;;;                                                                                         } 44 DeclItem
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = format
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                   } 41 ParameterDeclaration
;;;                                                                                   { 41 StringExpression
;--     load_rr_string
        MOVE    #Cstr_72, RR
;;;                                                                                   } 41 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                 } 40 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                               } 39 Expr l(r)
;;;                                                                             } 38 ExpressionStatement
;;;                                                                             { 38 for Statement
;;;                                                                               { 39 ExpressionStatement
;;;                                                                                 { 40 Expr l = r
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = int (80000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = col
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                   { 41 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                   } 41 NumericExpression (constant 0 = 0x0)
;--     store_rr_var col = -5(FP), SP at -5
        MOVE    RR, 0(SP)
;;;                                                                                 } 40 Expr l = r
;;;                                                                               } 39 ExpressionStatement
;--     branch
        JMP     L34_tst_103
L34_loop_103:
;;;                                                                               { 39 ExpressionStatement
;;;                                                                                 { 40 Expr l(r)
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = int (80000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = printf
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                   { 41 Expr (l , r)
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = true
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = const char (20100)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = format
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr * r
;;;                                                                                       { 43 Expr l - r
;;;                                                                                         { 44 Expr ++r
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (address)
;--     load_rr_var address = 2(FP), SP at -5 (16 bit)
        MOVE    7(SP), RR
;;;                                                                                           } 45 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var address = 2(FP), SP at -5
        MOVE    RR, 7(SP)
;;;                                                                                         } 44 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                                       } 43 Expr l - r
;--     content
        MOVE    (RR), RU
;;;                                                                                     } 42 Expr * r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = true
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = const char (20100)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = format
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 StringExpression
;--     load_rr_string
        MOVE    #Cstr_73, RR
;;;                                                                                     } 42 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                   } 41 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                 } 40 Expr l(r)
;;;                                                                               } 39 ExpressionStatement
L34_cont_103:
;;;                                                                               { 39 Expr l - r
;;;                                                                                 { 40 Expr ++r
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (col)
;--     load_rr_var col = -5(FP), SP at -5 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                   } 41 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var col = -5(FP), SP at -5
        MOVE    RR, 0(SP)
;;;                                                                                 } 40 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                               } 39 Expr l - r
L34_tst_103:
;;;                                                                               { 39 Expr l < r
;;;                                                                                 { 40 TypeName (internal)
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = int (80000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                 } 40 TypeName (internal)
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (col)
;--     load_rr_var col = -5(FP), SP at -5 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                 } 40 Expression (variable name)
;--     l < r
        SLT     RR, #0x0010
;;;                                                                               } 39 Expr l < r
;--     branch_true
        JMP     RRNZ, L34_loop_103
L34_brk_104:
;;;                                                                             } 38 for Statement
;;;                                                                             { 38 ExpressionStatement
;;;                                                                               { 39 Expr l -= r
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = unsigned char (22000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_POINTER
;;;                                                                                       { 43 List
;;;                                                                                         { 44 Ptr
;;;                                                                                         } 44 Ptr
;;;                                                                                       } 43 List
;;;                                                                                     } 42 DeclItem
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = address
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                                 { 40 Expr l - r
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (address)
;--     load_rr_var address = 2(FP), SP at -5 (16 bit)
        MOVE    7(SP), RR
;;;                                                                                   } 41 Expression (variable name)
;--     l - r
        SUB     RR, #0x0010
;;;                                                                                 } 40 Expr l - r
;--     store_rr_var address = 2(FP), SP at -5
        MOVE    RR, 7(SP)
;;;                                                                               } 39 Expr l -= r
;;;                                                                             } 38 ExpressionStatement
;;;                                                                             { 38 ExpressionStatement
;;;                                                                               { 39 Expr l(r)
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = int (80000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = printf
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 StringExpression
;--     load_rr_string
        MOVE    #Cstr_74, RR
;;;                                                                                 } 40 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                               } 39 Expr l(r)
;;;                                                                             } 38 ExpressionStatement
;;;                                                                             { 38 for Statement
;;;                                                                               { 39 ExpressionStatement
;;;                                                                                 { 40 Expr l = r
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = int (80000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = col
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                   { 41 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                   } 41 NumericExpression (constant 0 = 0x0)
;--     store_rr_var col = -5(FP), SP at -5
        MOVE    RR, 0(SP)
;;;                                                                                 } 40 Expr l = r
;;;                                                                               } 39 ExpressionStatement
;--     branch
        JMP     L34_tst_105
L34_loop_105:
;;;                                                                               { 39 CompoundStatement
;;;                                                                                 { 40 List
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l = r
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = char (20000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = c
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 Expr * r
;;;                                                                                         { 44 Expr l - r
;;;                                                                                           { 45 Expr ++r
;;;                                                                                             { 46 Expression (variable name)
;;;                                                                                               expr_type = "identifier" (address)
;--     load_rr_var address = 2(FP), SP at -5 (16 bit)
        MOVE    7(SP), RR
;;;                                                                                             } 46 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var address = 2(FP), SP at -5
        MOVE    RR, 7(SP)
;;;                                                                                           } 45 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                                         } 44 Expr l - r
;--     content
        MOVE    (RR), RU
;;;                                                                                       } 43 Expr * r
;--     store_rr_var c = -1(FP), SP at -5
        MOVE    R, 4(SP)
;;;                                                                                     } 42 Expr l = r
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 IfElseStatement
;;;                                                                                     { 42 Expr l < r
;;;                                                                                       { 43 TypeName (internal)
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                       } 43 TypeName (internal)
;;;                                                                                       { 43 Expression (variable name)
;;;                                                                                         expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -5 (8 bit)
        MOVE    4(SP), RS
;;;                                                                                       } 43 Expression (variable name)
;--     l < r
        SLT     RR, #0x0020
;;;                                                                                     } 42 Expr l < r
;--     branch_false
        JMP     RRZ, L34_else_107
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l(r)
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = putchr
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = false
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = char (20000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = c
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 NumericExpression (constant 46 = 0x2E)
;--     load_rr_constant
        MOVE    #0x002E, RR
;;;                                                                                         } 44 NumericExpression (constant 46 = 0x2E)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                       } 43 Expr l(r)
;;;                                                                                     } 42 ExpressionStatement
;--     branch
        JMP     L34_endif_107
L34_else_107:
;;;                                                                                     { 42 IfElseStatement
;;;                                                                                       { 43 Expr l < r
;;;                                                                                         { 44 TypeName (internal)
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                         } 44 TypeName (internal)
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -5 (8 bit)
        MOVE    4(SP), RS
;;;                                                                                         } 44 Expression (variable name)
;--     l < r
        SLT     RR, #0x007F
;;;                                                                                       } 43 Expr l < r
;--     branch_false
        JMP     RRZ, L34_else_108
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = putchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = char (20000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = c
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (c)
;--     load_rr_var c = -1(FP), SP at -5 (8 bit)
        MOVE    4(SP), RS
;;;                                                                                           } 45 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;--     branch
        JMP     L34_endif_108
L34_else_108:
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = putchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = char (20000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = c
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 NumericExpression (constant 46 = 0x2E)
;--     load_rr_constant
        MOVE    #0x002E, RR
;;;                                                                                           } 45 NumericExpression (constant 46 = 0x2E)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
L34_endif_108:
;;;                                                                                     } 42 IfElseStatement
L34_endif_107:
;;;                                                                                   } 41 IfElseStatement
;;;                                                                                 } 40 List
;--     pop 0 bytes
;;;                                                                               } 39 CompoundStatement
L34_cont_105:
;;;                                                                               { 39 Expr l - r
;;;                                                                                 { 40 Expr ++r
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (col)
;--     load_rr_var col = -5(FP), SP at -5 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                   } 41 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var col = -5(FP), SP at -5
        MOVE    RR, 0(SP)
;;;                                                                                 } 40 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                               } 39 Expr l - r
L34_tst_105:
;;;                                                                               { 39 Expr l < r
;;;                                                                                 { 40 TypeName (internal)
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = int (80000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                 } 40 TypeName (internal)
;;;                                                                                 { 40 Expression (variable name)
;;;                                                                                   expr_type = "identifier" (col)
;--     load_rr_var col = -5(FP), SP at -5 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                 } 40 Expression (variable name)
;--     l < r
        SLT     RR, #0x0010
;;;                                                                               } 39 Expr l < r
;--     branch_true
        JMP     RRNZ, L34_loop_105
L34_brk_106:
;;;                                                                             } 38 for Statement
;;;                                                                             { 38 ExpressionStatement
;;;                                                                               { 39 Expr l(r)
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = int (80000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = printf
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;;;                                                                                 { 40 ParameterDeclaration
;;;                                                                                   isEllipsis = true
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = const char (20100)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_POINTER
;;;                                                                                         { 44 List
;;;                                                                                           { 45 Ptr
;;;                                                                                           } 45 Ptr
;;;                                                                                         } 44 List
;;;                                                                                       } 43 DeclItem
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = format
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;;;                                                                                 } 40 ParameterDeclaration
;;;                                                                                 { 40 StringExpression
;--     load_rr_string
        MOVE    #Cstr_75, RR
;;;                                                                                 } 40 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                               } 39 Expr l(r)
;;;                                                                             } 38 ExpressionStatement
;;;                                                                           } 37 List
;--     pop 0 bytes
;;;                                                                         } 36 CompoundStatement
L34_cont_101:
;;;                                                                         { 36 Expr l - r
;;;                                                                           { 37 Expr ++r
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (row)
;--     load_rr_var row = -3(FP), SP at -5 (16 bit)
        MOVE    2(SP), RR
;;;                                                                             } 38 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var row = -3(FP), SP at -5
        MOVE    RR, 2(SP)
;;;                                                                           } 37 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                         } 36 Expr l - r
L34_tst_101:
;;;                                                                         { 36 Expr l < r
;;;                                                                           { 37 TypeName (internal)
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = int (80000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                           } 37 TypeName (internal)
;;;                                                                           { 37 Expression (variable name)
;;;                                                                             expr_type = "identifier" (row)
;--     load_rr_var row = -3(FP), SP at -5 (16 bit)
        MOVE    2(SP), RR
;;;                                                                           } 37 Expression (variable name)
;--     l < r
        SLT     RR, #0x0010
;;;                                                                         } 36 Expr l < r
;--     branch_true
        JMP     RRNZ, L34_loop_101
L34_brk_102:
;;;                                                                       } 35 for Statement
;;;                                                                     } 34 List
;--     pop 5 bytes
        ADD     SP, #5
;;;                                                                   } 33 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                                   { 33 FunctionDefinition
;;;                                                                     { 34 TypeName
;;;                                                                       { 35 TypeSpecifier (all)
;;;                                                                         spec = int (80000)
;;;                                                                       } 35 TypeSpecifier (all)
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = main
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
;;;                                                                     } 34 TypeName
;;;                                                                     { 34 List
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_NAME
;;;                                                                         name = main
;;;                                                                       } 35 DeclItem
;;;                                                                       { 35 DeclItem
;;;                                                                         what = DECL_FUN
;;;                                                                       } 35 DeclItem
;;;                                                                     } 34 List
Cmain:
;;;                                                                     { 34 CompoundStatement
;;;                                                                       { 35 InitDeclarator
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = i
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                       } 35 InitDeclarator
;;;                                                                       { 35 List
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l(r)
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = void (10000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = init_unused
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;--     push 0 bytes
;--     call
        CALL    Cinit_unused
;--     pop 0 bytes
;;;                                                                           } 37 Expr l(r)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l(r)
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = void (10000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = init_stack
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;--     push 0 bytes
;--     call
        CALL    Cinit_stack
;--     pop 0 bytes
;;;                                                                           } 37 Expr l(r)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 ExpressionStatement
        MOVE #0x00, RR
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 ExpressionStatement
        OUT  R, (OUT_INT_MASK)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 for Statement
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l = r
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = i
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                               { 39 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                               } 39 NumericExpression (constant 0 = 0x0)
;--     store_rr_var i = -2(FP), SP at -2
        MOVE    RR, 0(SP)
;;;                                                                             } 38 Expr l = r
;;;                                                                           } 37 ExpressionStatement
;--     branch
        JMP     L35_tst_109
L35_loop_109:
;;;                                                                           { 37 ExpressionStatement
        EI
;;;                                                                           } 37 ExpressionStatement
L35_cont_109:
;;;                                                                           { 37 Expr ++r
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (i)
;--     load_rr_var i = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                             } 38 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var i = -2(FP), SP at -2
        MOVE    RR, 0(SP)
;;;                                                                           } 37 Expr ++r
L35_tst_109:
;;;                                                                           { 37 Expr l < r
;;;                                                                             { 38 TypeName (internal)
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = int (80000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                             } 38 TypeName (internal)
;;;                                                                             { 38 Expression (variable name)
;;;                                                                               expr_type = "identifier" (i)
;--     load_rr_var i = -2(FP), SP at -2 (16 bit)
        MOVE    0(SP), RR
;;;                                                                             } 38 Expression (variable name)
;--     l < r
        SLT     RR, #0x0010
;;;                                                                           } 37 Expr l < r
;--     branch_true
        JMP     RRNZ, L35_loop_109
L35_brk_110:
;;;                                                                         } 36 for Statement
;;;                                                                         { 36 ExpressionStatement
        MOVE #0x05, RR
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 ExpressionStatement
        OUT  R, (OUT_INT_MASK)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 ExpressionStatement
;;;                                                                           { 37 Expr l(r)
;;;                                                                             { 38 TypeName
;;;                                                                               { 39 TypeSpecifier (all)
;;;                                                                                 spec = void (10000)
;;;                                                                               } 39 TypeSpecifier (all)
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = deschedule
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;;;                                                                             } 38 TypeName
;--     push 0 bytes
;--     call
        CALL    Cdeschedule
;--     pop 0 bytes
;;;                                                                           } 37 Expr l(r)
;;;                                                                         } 36 ExpressionStatement
;;;                                                                         { 36 for Statement
;;;                                                                           { 37 ExpressionStatement
;;;                                                                           } 37 ExpressionStatement
L35_loop_111:
;;;                                                                           { 37 ExpressionStatement
        HALT
;;;                                                                           } 37 ExpressionStatement
L35_cont_111:
;--     branch
        JMP     L35_loop_111
L35_brk_112:
;;;                                                                         } 36 for Statement
;;;                                                                       } 35 List
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                     } 34 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                                     { 34 FunctionDefinition
;;;                                                                       { 35 TypeName
;;;                                                                         { 36 TypeSpecifier (all)
;;;                                                                           spec = int (80000)
;;;                                                                         } 36 TypeSpecifier (all)
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = main_1
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
;;;                                                                       } 35 TypeName
;;;                                                                       { 35 List
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_NAME
;;;                                                                           name = main_1
;;;                                                                         } 36 DeclItem
;;;                                                                         { 36 DeclItem
;;;                                                                           what = DECL_FUN
;;;                                                                           { 37 List
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = false
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = int (80000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = argc
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                             { 38 ParameterDeclaration
;;;                                                                               isEllipsis = false
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = char (20000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_POINTER
;;;                                                                                     { 42 List
;;;                                                                                       { 43 Ptr
;;;                                                                                       } 43 Ptr
;;;                                                                                     } 42 List
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = argv
;;;                                                                                   } 41 DeclItem
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_ARRAY
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;;;                                                                             } 38 ParameterDeclaration
;;;                                                                           } 37 List
;;;                                                                         } 36 DeclItem
;;;                                                                       } 35 List
Cmain_1:
;;;                                                                       { 35 CompoundStatement
;;;                                                                         { 36 InitDeclarator
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = c
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                         } 36 InitDeclarator
;;;                                                                         { 36 InitDeclarator
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = last_c
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                                                         } 36 InitDeclarator
;;;                                                                         { 36 InitDeclarator
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_POINTER
;;;                                                                               { 39 List
;;;                                                                                 { 40 Ptr
;;;                                                                                 } 40 Ptr
;;;                                                                               } 39 List
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = address
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                         } 36 InitDeclarator
;;;                                                                         { 36 InitDeclarator
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = value
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                         } 36 InitDeclarator
;;;                                                                         { 36 List
;;;                                                                           { 37 ExpressionStatement
        EI
;;;                                                                           } 37 ExpressionStatement
;;;                                                                           { 37 ExpressionStatement
;;;                                                                             { 38 Expr l(r)
;;;                                                                               { 39 TypeName
;;;                                                                                 { 40 TypeSpecifier (all)
;;;                                                                                   spec = void (10000)
;;;                                                                                 } 40 TypeSpecifier (all)
;;;                                                                                 { 40 List
;;;                                                                                   { 41 DeclItem
;;;                                                                                     what = DECL_NAME
;;;                                                                                     name = init_stack
;;;                                                                                   } 41 DeclItem
;;;                                                                                 } 40 List
;;;                                                                               } 39 TypeName
;--     push 0 bytes
;--     call
        CALL    Cinit_stack
;--     pop 0 bytes
;;;                                                                             } 38 Expr l(r)
;;;                                                                           } 37 ExpressionStatement
;;;                                                                           { 37 for Statement
;;;                                                                             { 38 ExpressionStatement
;;;                                                                             } 38 ExpressionStatement
L36_loop_113:
;;;                                                                             { 38 CompoundStatement
;;;                                                                               { 39 List
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                   { 41 Expr l(r)
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = void (10000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = P
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = false
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (struct/union)
;;;                                                                                           spec = struct '_semaphore' (800000)
;;;                                                                                           name = _semaphore
;;;                                                                                         } 44 TypeSpecifier (struct/union)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = sema
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                     } 42 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                   } 41 Expr l(r)
;;;                                                                                 } 40 ExpressionStatement
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                   { 41 Expr l(r)
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = int (80000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = printf
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = true
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = const char (20100)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = format
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 StringExpression
;--     load_rr_string
        MOVE    #Cstr_83, RR
;;;                                                                                     } 42 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                   } 41 Expr l(r)
;;;                                                                                 } 40 ExpressionStatement
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                   { 41 Expr l(r)
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = void (10000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = V
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = false
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (struct/union)
;;;                                                                                           spec = struct '_semaphore' (800000)
;;;                                                                                           name = _semaphore
;;;                                                                                         } 44 TypeSpecifier (struct/union)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = sema
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                     } 42 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                   } 41 Expr l(r)
;;;                                                                                 } 40 ExpressionStatement
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                   { 41 Expr l = r
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = char (20000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = last_c
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                     { 42 Expression (variable name)
;;;                                                                                       expr_type = "identifier" (c)
;--     load_rr_var c = -2(FP), SP at -7 (16 bit)
        MOVE    5(SP), RR
;;;                                                                                     } 42 Expression (variable name)
;--     store_rr_var last_c = -3(FP), SP at -7
        MOVE    R, 4(SP)
;;;                                                                                   } 41 Expr l = r
;;;                                                                                 } 40 ExpressionStatement
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                   { 41 Expr l = r
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = int (80000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = c
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = getchr_timed
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = unsigned int (82000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = ticks
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 NumericExpression (constant 60000 = 0xEA60)
;--     load_rr_constant
        MOVE    #0xEA60, RR
;;;                                                                                       } 43 NumericExpression (constant 60000 = 0xEA60)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cgetchr_timed
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;--     store_rr_var c = -2(FP), SP at -7
        MOVE    RR, 5(SP)
;;;                                                                                   } 41 Expr l = r
;;;                                                                                 } 40 ExpressionStatement
;;;                                                                                 { 40 IfElseStatement
;;;                                                                                   { 41 Expr l == r
;;;                                                                                     { 42 TypeName (internal)
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = int (80000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                     } 42 TypeName (internal)
;;;                                                                                     { 42 Expression (variable name)
;;;                                                                                       expr_type = "identifier" (c)
;--     load_rr_var c = -2(FP), SP at -7 (16 bit)
        MOVE    5(SP), RR
;;;                                                                                     } 42 Expression (variable name)
;--     l == r
        SEQ     RR, #0xFFFF
;;;                                                                                   } 41 Expr l == r
;--     branch_false
        JMP     RRZ, L36_endif_115
;;;                                                                                   { 41 CompoundStatement
;;;                                                                                     { 42 List
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = void (10000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = P
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (struct/union)
;;;                                                                                                 spec = struct '_semaphore' (800000)
;;;                                                                                                 name = _semaphore
;;;                                                                                               } 47 TypeSpecifier (struct/union)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = sema
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                           } 45 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 Expr (l , r)
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = true
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = const char (20100)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = format
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 Expr * r
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (current_task)
;--     load_rr_var current_task, (16 bit)
        MOVE    (Ccurrent_task), RR
;;;                                                                                               } 47 Expression (variable name)
;;;                                                                                             } 46 Expr * r
;--     + (member)
        ADD     RR, #0x0006
;--     content
        MOVE    (RR), RR
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = true
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = const char (20100)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = format
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 StringExpression
;--     load_rr_string
        MOVE    #Cstr_84, RR
;;;                                                                                             } 46 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                           } 45 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = void (10000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = V
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (struct/union)
;;;                                                                                                 spec = struct '_semaphore' (800000)
;;;                                                                                                 name = _semaphore
;;;                                                                                               } 47 TypeSpecifier (struct/union)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = sema
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                           } 45 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_cont_113
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                     } 42 List
;--     pop 0 bytes
;;;                                                                                   } 41 CompoundStatement
L36_endif_115:
;;;                                                                                 } 40 IfElseStatement
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                   { 41 Expr l(r)
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = void (10000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = P
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = false
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (struct/union)
;;;                                                                                           spec = struct '_semaphore' (800000)
;;;                                                                                           name = _semaphore
;;;                                                                                         } 44 TypeSpecifier (struct/union)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = sema
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                     } 42 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                   } 41 Expr l(r)
;;;                                                                                 } 40 ExpressionStatement
;;;                                                                                 { 40 SwitchStatement
;;;                                                                                   { 41 Expression (variable name)
;;;                                                                                     expr_type = "identifier" (c)
;--     load_rr_var c = -2(FP), SP at -7 (16 bit)
        MOVE    5(SP), RR
;;;                                                                                   } 41 Expression (variable name)
;--     move_rr_to_ll
        MOVE    RR, LL
;--     branch_case (16 bit)
        SEQ     LL, #0x000D
        JMP     RRNZ, L36_case_116_000D
;--     branch_case (16 bit)
        SEQ     LL, #0x000A
        JMP     RRNZ, L36_case_116_000A
;--     branch_case (16 bit)
        SEQ     LL, #0x0032
        JMP     RRNZ, L36_case_116_0032
;--     branch_case (16 bit)
        SEQ     LL, #0x0033
        JMP     RRNZ, L36_case_116_0033
;--     branch_case (16 bit)
        SEQ     LL, #0x0062
        JMP     RRNZ, L36_case_116_0062
;--     branch_case (16 bit)
        SEQ     LL, #0x0063
        JMP     RRNZ, L36_case_116_0063
;--     branch_case (16 bit)
        SEQ     LL, #0x0064
        JMP     RRNZ, L36_case_116_0064
;--     branch_case (16 bit)
        SEQ     LL, #0x0065
        JMP     RRNZ, L36_case_116_0065
;--     branch_case (16 bit)
        SEQ     LL, #0x006D
        JMP     RRNZ, L36_case_116_006D
;--     branch_case (16 bit)
        SEQ     LL, #0x0073
        JMP     RRNZ, L36_case_116_0073
;--     branch_case (16 bit)
        SEQ     LL, #0x0074
        JMP     RRNZ, L36_case_116_0074
;--     branch_case (16 bit)
        SEQ     LL, #0x0048
        JMP     RRNZ, L36_case_116_0048
;--     branch_case (16 bit)
        SEQ     LL, #0x0049
        JMP     RRNZ, L36_case_116_0049
;--     branch_case (16 bit)
        SEQ     LL, #0x0053
        JMP     RRNZ, L36_case_116_0053
;--     branch_case (16 bit)
        SEQ     LL, #0x0054
        JMP     RRNZ, L36_case_116_0054
;--     branch
        JMP     L36_deflt_116
;;;                                                                                   { 41 CompoundStatement
;;;                                                                                     { 42 List
;;;                                                                                       { 43 case Statement
L36_case_116_000D:
;;;                                                                                         { 44 case Statement
L36_case_116_000A:
;;;                                                                                           { 45 IfElseStatement
;;;                                                                                             { 46 Expr l == r
;;;                                                                                               { 47 TypeName (internal)
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                               } 47 TypeName (internal)
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (last_c)
;--     load_rr_var last_c = -3(FP), SP at -7 (8 bit)
        MOVE    4(SP), RS
;;;                                                                                               } 47 Expression (variable name)
;--     l == r
        SEQ     RR, #0x0064
;;;                                                                                             } 46 Expr l == r
;--     branch_false
        JMP     RRZ, L36_endif_117
;;;                                                                                             { 46 CompoundStatement
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 ExpressionStatement
;;;                                                                                                   { 49 Expr l += r
;;;                                                                                                     { 50 TypeName
;;;                                                                                                       { 51 TypeSpecifier (all)
;;;                                                                                                         spec = unsigned char (22000)
;;;                                                                                                       } 51 TypeSpecifier (all)
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 DeclItem
;;;                                                                                                           what = DECL_POINTER
;;;                                                                                                           { 53 List
;;;                                                                                                             { 54 Ptr
;;;                                                                                                             } 54 Ptr
;;;                                                                                                           } 53 List
;;;                                                                                                         } 52 DeclItem
;;;                                                                                                         { 52 DeclItem
;;;                                                                                                           what = DECL_NAME
;;;                                                                                                           name = address
;;;                                                                                                         } 52 DeclItem
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 TypeName
;;;                                                                                                     { 50 Expr l + r
;;;                                                                                                       { 51 Expression (variable name)
;;;                                                                                                         expr_type = "identifier" (address)
;--     load_rr_var address = -5(FP), SP at -7 (16 bit)
        MOVE    2(SP), RR
;;;                                                                                                       } 51 Expression (variable name)
;--     l + r
        ADD     RR, #0x0100
;;;                                                                                                     } 50 Expr l + r
;--     store_rr_var address = -5(FP), SP at -7
        MOVE    RR, 2(SP)
;;;                                                                                                   } 49 Expr l += r
;;;                                                                                                 } 48 ExpressionStatement
;;;                                                                                                 { 48 ExpressionStatement
;;;                                                                                                   { 49 Expr l(r)
;;;                                                                                                     { 50 TypeName
;;;                                                                                                       { 51 TypeSpecifier (all)
;;;                                                                                                         spec = int (80000)
;;;                                                                                                       } 51 TypeSpecifier (all)
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 DeclItem
;;;                                                                                                           what = DECL_NAME
;;;                                                                                                           name = putchr
;;;                                                                                                         } 52 DeclItem
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 TypeName
;;;                                                                                                     { 50 ParameterDeclaration
;;;                                                                                                       isEllipsis = false
;;;                                                                                                       { 51 TypeName
;;;                                                                                                         { 52 TypeSpecifier (all)
;;;                                                                                                           spec = char (20000)
;;;                                                                                                         } 52 TypeSpecifier (all)
;;;                                                                                                         { 52 List
;;;                                                                                                           { 53 DeclItem
;;;                                                                                                             what = DECL_NAME
;;;                                                                                                             name = c
;;;                                                                                                           } 53 DeclItem
;;;                                                                                                         } 52 List
;;;                                                                                                       } 51 TypeName
;;;                                                                                                     } 50 ParameterDeclaration
;;;                                                                                                     { 50 NumericExpression (constant 13 = 0xD)
;--     load_rr_constant
        MOVE    #0x000D, RR
;;;                                                                                                     } 50 NumericExpression (constant 13 = 0xD)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                                   } 49 Expr l(r)
;;;                                                                                                 } 48 ExpressionStatement
;;;                                                                                                 { 48 ExpressionStatement
;;;                                                                                                   { 49 Expr l(r)
;;;                                                                                                     { 50 TypeName
;;;                                                                                                       { 51 TypeSpecifier (all)
;;;                                                                                                         spec = void (10000)
;;;                                                                                                       } 51 TypeSpecifier (all)
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 DeclItem
;;;                                                                                                           what = DECL_NAME
;;;                                                                                                           name = display_memory
;;;                                                                                                         } 52 DeclItem
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 TypeName
;;;                                                                                                     { 50 ParameterDeclaration
;;;                                                                                                       isEllipsis = false
;;;                                                                                                       { 51 TypeName
;;;                                                                                                         { 52 TypeSpecifier (all)
;;;                                                                                                           spec = unsigned char (22000)
;;;                                                                                                         } 52 TypeSpecifier (all)
;;;                                                                                                         { 52 List
;;;                                                                                                           { 53 DeclItem
;;;                                                                                                             what = DECL_POINTER
;;;                                                                                                             { 54 List
;;;                                                                                                               { 55 Ptr
;;;                                                                                                               } 55 Ptr
;;;                                                                                                             } 54 List
;;;                                                                                                           } 53 DeclItem
;;;                                                                                                           { 53 DeclItem
;;;                                                                                                             what = DECL_NAME
;;;                                                                                                             name = address
;;;                                                                                                           } 53 DeclItem
;;;                                                                                                         } 52 List
;;;                                                                                                       } 51 TypeName
;;;                                                                                                     } 50 ParameterDeclaration
;;;                                                                                                     { 50 Expression (variable name)
;;;                                                                                                       expr_type = "identifier" (address)
;--     load_rr_var address = -5(FP), SP at -7 (16 bit)
        MOVE    2(SP), RR
;;;                                                                                                     } 50 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cdisplay_memory
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                                   } 49 Expr l(r)
;;;                                                                                                 } 48 ExpressionStatement
;;;                                                                                                 { 48 ExpressionStatement
;;;                                                                                                   { 49 Expr l = r
;;;                                                                                                     { 50 TypeName
;;;                                                                                                       { 51 TypeSpecifier (all)
;;;                                                                                                         spec = int (80000)
;;;                                                                                                       } 51 TypeSpecifier (all)
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 DeclItem
;;;                                                                                                           what = DECL_NAME
;;;                                                                                                           name = c
;;;                                                                                                         } 52 DeclItem
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 TypeName
;;;                                                                                                     { 50 NumericExpression (constant 100 = 0x64)
;--     load_rr_constant
        MOVE    #0x0064, RR
;;;                                                                                                     } 50 NumericExpression (constant 100 = 0x64)
;--     store_rr_var c = -2(FP), SP at -7
        MOVE    RR, 5(SP)
;;;                                                                                                   } 49 Expr l = r
;;;                                                                                                 } 48 ExpressionStatement
;;;                                                                                               } 47 List
;--     pop 0 bytes
;;;                                                                                             } 46 CompoundStatement
L36_endif_117:
;;;                                                                                           } 45 IfElseStatement
;;;                                                                                         } 44 case Statement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0032:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = V
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = false
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (struct/union)
;;;                                                                                                   spec = struct '_semaphore' (800000)
;;;                                                                                                   name = _semaphore
;;;                                                                                                 } 48 TypeSpecifier (struct/union)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = sema
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 Expr & r
;--     load_address t2_control
        MOVE    #Ct2_control, RR
;;;                                                                                             } 46 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = true
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = const char (20100)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = format
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 StringExpression
;--     load_rr_string
        MOVE    #Cstr_85, RR
;;;                                                                                           } 45 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0033:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = V
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = false
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (struct/union)
;;;                                                                                                   spec = struct '_semaphore' (800000)
;;;                                                                                                   name = _semaphore
;;;                                                                                                 } 48 TypeSpecifier (struct/union)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = sema
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 Expr & r
;--     load_address t3_control
        MOVE    #Ct3_control, RR
;;;                                                                                             } 46 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = void (10000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = sleep
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = millisecs
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 NumericExpression (constant 100 = 0x64)
;--     load_rr_constant
        MOVE    #0x0064, RR
;;;                                                                                           } 45 NumericExpression (constant 100 = 0x64)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Csleep
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = void (10000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = P
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (struct/union)
;;;                                                                                                 spec = struct '_semaphore' (800000)
;;;                                                                                                 name = _semaphore
;;;                                                                                               } 47 TypeSpecifier (struct/union)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = sema
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expr & r
;--     load_address t3_control
        MOVE    #Ct3_control, RR
;;;                                                                                           } 45 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = true
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = const char (20100)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = format
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 StringExpression
;--     load_rr_string
        MOVE    #Cstr_86, RR
;;;                                                                                           } 45 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0062:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                           } 45 NumericExpression (constant 0 = 0x0)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 ExpressionStatement
        OUT  R, (OUT_START_CLK_CTR)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = void (10000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = deschedule
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;--     push 0 bytes
;--     call
        CALL    Cdeschedule
;--     pop 0 bytes
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
        OUT  R, (OUT_STOP_CLK_CTR)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l = r
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = value
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 Expr l | r
;;;                                                                                             { 46 TypeName (internal)
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                             } 46 TypeName (internal)
;;;                                                                                             { 46 Expr l << r
;;;                                                                                               { 47 TypeName (internal)
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                               } 47 TypeName (internal)
        IN   (IN_CLK_CTR_HIGH), RU
;--     l << r
        LSL     RR, #0x0008
;;;                                                                                             } 46 Expr l << r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
        IN   (IN_CLK_CTR_LOW), RU
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     l | r
        OR      LL, RR
;;;                                                                                           } 45 Expr l | r
;--     store_rr_var value = -7(FP), SP at -7
        MOVE    RR, 0(SP)
;;;                                                                                         } 44 Expr l = r
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 Expr (l , r)
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = true
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = const char (20100)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = format
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 Expr l / r
;;;                                                                                               { 47 TypeName (internal)
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                               } 47 TypeName (internal)
;;;                                                                                               { 47 Expr l + r
;;;                                                                                                 { 48 Expression (variable name)
;;;                                                                                                   expr_type = "identifier" (value)
;--     load_rr_var value = -7(FP), SP at -7 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                                 } 48 Expression (variable name)
;--     l + r
        ADD     RR, #0x000A
;;;                                                                                               } 47 Expr l + r
;--     l / r
        MOVE    RR, LL
        MOVE    #0x0014, RR
;--     l / r
        DI
        DIV_IS
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                                             } 46 Expr l / r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                             { 46 Expr (l , r)
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = true
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = const char (20100)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_POINTER
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 Ptr
;;;                                                                                                         } 52 Ptr
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = format
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (value)
;--     load_rr_var value = -7(FP), SP at -9 (16 bit)
        MOVE    2(SP), RR
;;;                                                                                               } 47 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = true
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = const char (20100)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_POINTER
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 Ptr
;;;                                                                                                         } 52 Ptr
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = format
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
;;;                                                                                               { 47 StringExpression
;--     load_rr_string
        MOVE    #Cstr_91, RR
;;;                                                                                               } 47 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                             } 46 Expr (l , r)
;;;                                                                                           } 45 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 6 bytes
        ADD     SP, #6
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0063:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = show_time
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;--     push 0 bytes
;--     call
        CALL    Cshow_time
;--     pop 0 bytes
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0064:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l = r
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = char (20000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = last_c
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 NumericExpression (constant 100 = 0x64)
;--     load_rr_constant
        MOVE    #0x0064, RR
;;;                                                                                             } 46 NumericExpression (constant 100 = 0x64)
;--     store_rr_var last_c = -3(FP), SP at -7
        MOVE    R, 4(SP)
;;;                                                                                           } 45 Expr l = r
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = true
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = const char (20100)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = format
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 StringExpression
;--     load_rr_string
        MOVE    #Cstr_92, RR
;;;                                                                                           } 45 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l = r
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = unsigned char (22000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = address
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 Expression (cast)r
;;;                                                                                             { 46 Expr l(r)
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = gethex
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = false
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = char (20000)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = echo
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
;;;                                                                                               { 47 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                               } 47 NumericExpression (constant 1 = 0x1)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cgethex
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                             } 46 Expr l(r)
;;;                                                                                           } 45 Expression (cast)r
;--     store_rr_var address = -5(FP), SP at -7
        MOVE    RR, 2(SP)
;;;                                                                                         } 44 Expr l = r
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = true
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = const char (20100)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = format
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 StringExpression
;--     load_rr_string
        MOVE    #Cstr_93, RR
;;;                                                                                           } 45 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = getchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;--     push 2 bytes
;--     call
        CALL    Cgetchr
;--     pop 0 bytes
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = void (10000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = display_memory
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = unsigned char (22000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = address
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (address)
;--     load_rr_var address = -5(FP), SP at -7 (16 bit)
        MOVE    2(SP), RR
;;;                                                                                           } 45 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Cdisplay_memory
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0065:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = printf
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = true
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = const char (20100)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = format
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 StringExpression
;--     load_rr_string
        MOVE    #Cstr_94, RR
;;;                                                                                             } 46 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = gethex
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = char (20000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = echo
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                           } 45 NumericExpression (constant 1 = 0x1)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cgethex
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
        OUT R, (OUT_LEDS)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = true
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = const char (20100)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = format
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 StringExpression
;--     load_rr_string
        MOVE    #Cstr_96, RR
;;;                                                                                           } 45 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = getchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;--     push 2 bytes
;--     call
        CALL    Cgetchr
;--     pop 0 bytes
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_006D:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = printf
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = true
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = const char (20100)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = format
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 StringExpression
;--     load_rr_string
        MOVE    #Cstr_97, RR
;;;                                                                                             } 46 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l = r
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = unsigned char (22000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = address
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 Expression (cast)r
;;;                                                                                             { 46 Expr l(r)
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = gethex
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = false
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = char (20000)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = echo
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
;;;                                                                                               { 47 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                               } 47 NumericExpression (constant 1 = 0x1)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cgethex
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                             } 46 Expr l(r)
;;;                                                                                           } 45 Expression (cast)r
;--     store_rr_var address = -5(FP), SP at -7
        MOVE    RR, 2(SP)
;;;                                                                                         } 44 Expr l = r
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = true
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = const char (20100)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = format
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 StringExpression
;--     load_rr_string
        MOVE    #Cstr_98, RR
;;;                                                                                           } 45 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = getchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;--     push 2 bytes
;--     call
        CALL    Cgetchr
;--     pop 0 bytes
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l = r
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = unsigned char (22000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = address
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = gethex
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = false
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = char (20000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = echo
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                             } 46 NumericExpression (constant 1 = 0x1)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cgethex
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                           } 45 Expr l(r)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;;;                                                                                           { 45 Expr * r
;;;                                                                                             { 46 Expression (variable name)
;;;                                                                                               expr_type = "identifier" (address)
;--     load_rr_var address = -5(FP), SP at -8 (16 bit)
        MOVE    3(SP), RR
;;;                                                                                             } 46 Expression (variable name)
;;;                                                                                           } 45 Expr * r
;--     move_rr_to_ll
        MOVE    RR, LL
;--     pop_rr (8 bit)
        MOVE    (SP)+, RU
;--     assign (8 bit)
        MOVE    R, (LL)
;;;                                                                                         } 44 Expr l = r
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = getchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;--     push 2 bytes
;--     call
        CALL    Cgetchr
;--     pop 0 bytes
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = printf
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = true
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = const char (20100)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_POINTER
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 Ptr
;;;                                                                                                     } 50 Ptr
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 DeclItem
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = format
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 StringExpression
;--     load_rr_string
        MOVE    #Cstr_99, RR
;;;                                                                                           } 45 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0073:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = printf
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr (l , r)
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = true
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = const char (20100)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_POINTER
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 Ptr
;;;                                                                                                         } 52 Ptr
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = format
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
        IN (IN_DIP_SWITCH), RU
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = true
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = const char (20100)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_POINTER
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 Ptr
;;;                                                                                                         } 52 Ptr
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = format
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
;;;                                                                                               { 47 StringExpression
;--     load_rr_string
        MOVE    #Cstr_100, RR
;;;                                                                                               } 47 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                             } 46 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0074:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = printf
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr (l , r)
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = true
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = const char (20100)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_POINTER
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 Ptr
;;;                                                                                                         } 52 Ptr
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = format
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
        IN (IN_TEMPERAT), RU
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                               { 47 ParameterDeclaration
;;;                                                                                                 isEllipsis = true
;;;                                                                                                 { 48 TypeName
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = const char (20100)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                   { 49 List
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_POINTER
;;;                                                                                                       { 51 List
;;;                                                                                                         { 52 Ptr
;;;                                                                                                         } 52 Ptr
;;;                                                                                                       } 51 List
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                     { 50 DeclItem
;;;                                                                                                       what = DECL_NAME
;;;                                                                                                       name = format
;;;                                                                                                     } 50 DeclItem
;;;                                                                                                   } 49 List
;;;                                                                                                 } 48 TypeName
;;;                                                                                               } 47 ParameterDeclaration
;;;                                                                                               { 47 StringExpression
;--     load_rr_string
        MOVE    #Cstr_102, RR
;;;                                                                                               } 47 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                             } 46 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0048:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = printf
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = true
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = const char (20100)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = format
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 StringExpression
;--     load_rr_string
        MOVE    #Cstr_104, RR
;;;                                                                                             } 46 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 while Statement
L36_loop_118:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                         } 44 ExpressionStatement
L36_cont_118:
;;;                                                                                         { 44 Expr l < r
;;;                                                                                           { 45 TypeName (internal)
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                           } 45 TypeName (internal)
;--     load_address tx_sema
        MOVE    #Ctx_sema, RR
;--     + (member)
;--     content
        MOVE    (RR), RR
;--     l < r
        SLT     RR, #0x0010
;;;                                                                                         } 44 Expr l < r
;--     branch_true
        JMP     RRNZ, L36_loop_118
L36_brk_119:
;;;                                                                                       } 43 while Statement
;;;                                                                                       { 43 ExpressionStatement
        DI
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 ExpressionStatement
        HALT
;;;                                                                                       } 43 ExpressionStatement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0049:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = load_image
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;--     push 0 bytes
;--     call
        CALL    Cload_image
;--     pop 0 bytes
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0053:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = show_semas
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;--     push 0 bytes
;--     call
        CALL    Cshow_semas
;--     pop 0 bytes
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_case_116_0054:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = show_tasks
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;--     push 0 bytes
;--     call
        CALL    Cshow_tasks
;--     pop 0 bytes
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                       { 43 break/continue Statement
;--     branch
        JMP     L36_brk_116
;;;                                                                                       } 43 break/continue Statement
;;;                                                                                       { 43 case Statement
L36_deflt_116:
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = printf
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = true
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = const char (20100)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_POINTER
;;;                                                                                                     { 50 List
;;;                                                                                                       { 51 Ptr
;;;                                                                                                       } 51 Ptr
;;;                                                                                                     } 50 List
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = format
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 StringExpression
;--     load_rr_string
        MOVE    #Cstr_107, RR
;;;                                                                                             } 46 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 case Statement
;;;                                                                                     } 42 List
;--     pop 0 bytes
;;;                                                                                   } 41 CompoundStatement
L36_brk_116:
;;;                                                                                 } 40 SwitchStatement
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                   { 41 Expr l(r)
;;;                                                                                     { 42 TypeName
;;;                                                                                       { 43 TypeSpecifier (all)
;;;                                                                                         spec = void (10000)
;;;                                                                                       } 43 TypeSpecifier (all)
;;;                                                                                       { 43 List
;;;                                                                                         { 44 DeclItem
;;;                                                                                           what = DECL_NAME
;;;                                                                                           name = V
;;;                                                                                         } 44 DeclItem
;;;                                                                                       } 43 List
;;;                                                                                     } 42 TypeName
;;;                                                                                     { 42 ParameterDeclaration
;;;                                                                                       isEllipsis = false
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (struct/union)
;;;                                                                                           spec = struct '_semaphore' (800000)
;;;                                                                                           name = _semaphore
;;;                                                                                         } 44 TypeSpecifier (struct/union)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_POINTER
;;;                                                                                             { 46 List
;;;                                                                                               { 47 Ptr
;;;                                                                                               } 47 Ptr
;;;                                                                                             } 46 List
;;;                                                                                           } 45 DeclItem
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = sema
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                     } 42 ParameterDeclaration
;;;                                                                                     { 42 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                     } 42 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                   } 41 Expr l(r)
;;;                                                                                 } 40 ExpressionStatement
;;;                                                                               } 39 List
;--     pop 0 bytes
;;;                                                                             } 38 CompoundStatement
L36_cont_113:
;--     branch
        JMP     L36_loop_113
L36_brk_114:
;;;                                                                           } 37 for Statement
;;;                                                                         } 36 List
;--     pop 7 bytes
        ADD     SP, #7
;;;                                                                       } 35 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                                       { 35 FunctionDefinition
;;;                                                                         { 36 TypeName
;;;                                                                           { 37 TypeSpecifier (all)
;;;                                                                             spec = void (10000)
;;;                                                                           } 37 TypeSpecifier (all)
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = main_2
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
;;;                                                                         } 36 TypeName
;;;                                                                         { 36 List
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_NAME
;;;                                                                             name = main_2
;;;                                                                           } 37 DeclItem
;;;                                                                           { 37 DeclItem
;;;                                                                             what = DECL_FUN
;;;                                                                           } 37 DeclItem
;;;                                                                         } 36 List
Cmain_2:
;;;                                                                         { 36 CompoundStatement
;;;                                                                           { 37 InitDeclarator
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = all_value
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                           } 37 InitDeclarator
;;;                                                                           { 37 InitDeclarator
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = halt_value
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                           } 37 InitDeclarator
;;;                                                                           { 37 InitDeclarator
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = all_total
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                           } 37 InitDeclarator
;;;                                                                           { 37 InitDeclarator
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = halt_total
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                           } 37 InitDeclarator
;;;                                                                           { 37 InitDeclarator
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = n
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                           } 37 InitDeclarator
;;;                                                                           { 37 InitDeclarator
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = idle
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;--     push_zero 2 bytes
        CLRW    -(SP)
;;;                                                                           } 37 InitDeclarator
;;;                                                                           { 37 List
;;;                                                                             { 38 ExpressionStatement
        EI
;;;                                                                             } 38 ExpressionStatement
;;;                                                                             { 38 ExpressionStatement
;;;                                                                               { 39 Expr l(r)
;;;                                                                                 { 40 TypeName
;;;                                                                                   { 41 TypeSpecifier (all)
;;;                                                                                     spec = void (10000)
;;;                                                                                   } 41 TypeSpecifier (all)
;;;                                                                                   { 41 List
;;;                                                                                     { 42 DeclItem
;;;                                                                                       what = DECL_NAME
;;;                                                                                       name = init_stack
;;;                                                                                     } 42 DeclItem
;;;                                                                                   } 41 List
;;;                                                                                 } 40 TypeName
;--     push 0 bytes
;--     call
        CALL    Cinit_stack
;--     pop 0 bytes
;;;                                                                               } 39 Expr l(r)
;;;                                                                             } 38 ExpressionStatement
;;;                                                                             { 38 for Statement
;;;                                                                               { 39 ExpressionStatement
;;;                                                                               } 39 ExpressionStatement
L37_loop_120:
;;;                                                                               { 39 CompoundStatement
;;;                                                                                 { 40 List
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = void (10000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = P
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (struct/union)
;;;                                                                                             spec = struct '_semaphore' (800000)
;;;                                                                                             name = _semaphore
;;;                                                                                           } 45 TypeSpecifier (struct/union)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = sema
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr & r
;--     load_address t2_control
        MOVE    #Ct2_control, RR
;;;                                                                                       } 43 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l = r
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = unsigned int (82000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = all_value
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                       } 43 NumericExpression (constant 0 = 0x0)
;--     store_rr_var all_value = -2(FP), SP at -12
        MOVE    RR, 10(SP)
;;;                                                                                     } 42 Expr l = r
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l = r
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = unsigned int (82000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = halt_value
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                       } 43 NumericExpression (constant 0 = 0x0)
;--     store_rr_var halt_value = -4(FP), SP at -12
        MOVE    RR, 8(SP)
;;;                                                                                     } 42 Expr l = r
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l = r
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = unsigned int (82000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = all_total
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                       } 43 NumericExpression (constant 0 = 0x0)
;--     store_rr_var all_total = -6(FP), SP at -12
        MOVE    RR, 6(SP)
;;;                                                                                     } 42 Expr l = r
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l = r
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = unsigned int (82000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = halt_total
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                       } 43 NumericExpression (constant 0 = 0x0)
;--     store_rr_var halt_total = -8(FP), SP at -12
        MOVE    RR, 4(SP)
;;;                                                                                     } 42 Expr l = r
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = void (10000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = P
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (struct/union)
;;;                                                                                             spec = struct '_semaphore' (800000)
;;;                                                                                             name = _semaphore
;;;                                                                                           } 45 TypeSpecifier (struct/union)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = sema
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                       } 43 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = printf
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = true
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = const char (20100)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = format
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 StringExpression
;--     load_rr_string
        MOVE    #Cstr_123, RR
;;;                                                                                       } 43 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = void (10000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = V
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (struct/union)
;;;                                                                                             spec = struct '_semaphore' (800000)
;;;                                                                                             name = _semaphore
;;;                                                                                           } 45 TypeSpecifier (struct/union)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = sema
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                       } 43 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = void (10000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = V
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (struct/union)
;;;                                                                                             spec = struct '_semaphore' (800000)
;;;                                                                                             name = _semaphore
;;;                                                                                           } 45 TypeSpecifier (struct/union)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = sema
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr & r
;--     load_address t3_control
        MOVE    #Ct3_control, RR
;;;                                                                                       } 43 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 for Statement
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l = r
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = n
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                         } 44 NumericExpression (constant 0 = 0x0)
;--     store_rr_var n = -10(FP), SP at -12
        MOVE    RR, 2(SP)
;;;                                                                                       } 43 Expr l = r
;;;                                                                                     } 42 ExpressionStatement
;--     branch
        JMP     L37_tst_122
L37_loop_122:
;;;                                                                                     { 42 CompoundStatement
;;;                                                                                       { 43 List
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = sleep
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = false
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = millisecs
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                             } 46 NumericExpression (constant 1 = 0x1)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Csleep
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 NumericExpression (constant 0 = 0x0)
;--     load_rr_constant
        MOVE    #0x0000, RR
;;;                                                                                           } 45 NumericExpression (constant 0 = 0x0)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
        OUT  R, (OUT_START_CLK_CTR)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = sleep
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = false
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = millisecs
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                             } 46 NumericExpression (constant 1 = 0x1)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Csleep
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
        OUT  R, (OUT_STOP_CLK_CTR)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l += r
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = unsigned int (82000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = all_value
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr l + r
;;;                                                                                               { 47 Expr l | r
;;;                                                                                                 { 48 TypeName (internal)
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = int (80000)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                 } 48 TypeName (internal)
;;;                                                                                                 { 48 Expr l << r
;;;                                                                                                   { 49 TypeName (internal)
;;;                                                                                                     { 50 TypeSpecifier (all)
;;;                                                                                                       spec = int (80000)
;;;                                                                                                     } 50 TypeSpecifier (all)
;;;                                                                                                   } 49 TypeName (internal)
        IN   (IN_CLK_CTR_HIGH), RU
;--     l << r
        LSL     RR, #0x0008
;;;                                                                                                 } 48 Expr l << r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
        IN   (IN_CLK_CTR_LOW), RU
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     l | r
        OR      LL, RR
;;;                                                                                               } 47 Expr l | r
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (all_value)
;--     load_ll_var all_value = -2(FP), SP at -12 (16 bit)
        MOVE    10(SP), LL
;;;                                                                                               } 47 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                                             } 46 Expr l + r
;--     store_rr_var all_value = -2(FP), SP at -12
        MOVE    RR, 10(SP)
;;;                                                                                           } 45 Expr l += r
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l += r
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = unsigned int (82000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = all_total
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr l + r
;;;                                                                                               { 47 Expr l >> r
;;;                                                                                                 { 48 TypeName (internal)
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = int (80000)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                 } 48 TypeName (internal)
;;;                                                                                                 { 48 Expression (variable name)
;;;                                                                                                   expr_type = "identifier" (all_value)
;--     load_rr_var all_value = -2(FP), SP at -12 (16 bit)
        MOVE    10(SP), RR
;;;                                                                                                 } 48 Expression (variable name)
;--     l >> r
        ASR     RR, #0x0008
;;;                                                                                               } 47 Expr l >> r
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (all_total)
;--     load_ll_var all_total = -6(FP), SP at -12 (16 bit)
        MOVE    6(SP), LL
;;;                                                                                               } 47 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                                             } 46 Expr l + r
;--     store_rr_var all_total = -6(FP), SP at -12
        MOVE    RR, 6(SP)
;;;                                                                                           } 45 Expr l += r
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l & r
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = unsigned int (82000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = all_value
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr l & r
;;;                                                                                               { 47 TypeName (internal)
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = unsigned int (82000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                               } 47 TypeName (internal)
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (all_value)
;--     load_rr_var all_value = -2(FP), SP at -12 (16 bit)
        MOVE    10(SP), RR
;;;                                                                                               } 47 Expression (variable name)
;--     l & r
        AND     RR, #0x00FF
;;;                                                                                             } 46 Expr l & r
;--     store_rr_var all_value = -2(FP), SP at -12
        MOVE    RR, 10(SP)
;;;                                                                                           } 45 Expr l & r
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = sleep
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = false
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = millisecs
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                             } 46 NumericExpression (constant 1 = 0x1)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Csleep
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 NumericExpression (constant 3 = 0x3)
;--     load_rr_constant
        MOVE    #0x0003, RR
;;;                                                                                           } 45 NumericExpression (constant 3 = 0x3)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
        OUT  R, (OUT_START_CLK_CTR)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l(r)
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = void (10000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = sleep
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 ParameterDeclaration
;;;                                                                                               isEllipsis = false
;;;                                                                                               { 47 TypeName
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = int (80000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 DeclItem
;;;                                                                                                     what = DECL_NAME
;;;                                                                                                     name = millisecs
;;;                                                                                                   } 49 DeclItem
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 TypeName
;;;                                                                                             } 46 ParameterDeclaration
;;;                                                                                             { 46 NumericExpression (constant 1 = 0x1)
;--     load_rr_constant
        MOVE    #0x0001, RR
;;;                                                                                             } 46 NumericExpression (constant 1 = 0x1)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    Csleep
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                           } 45 Expr l(r)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
        OUT  R, (OUT_STOP_CLK_CTR)
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l += r
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = unsigned int (82000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = halt_value
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr l + r
;;;                                                                                               { 47 Expr l | r
;;;                                                                                                 { 48 TypeName (internal)
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = int (80000)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                 } 48 TypeName (internal)
;;;                                                                                                 { 48 Expr l << r
;;;                                                                                                   { 49 TypeName (internal)
;;;                                                                                                     { 50 TypeSpecifier (all)
;;;                                                                                                       spec = int (80000)
;;;                                                                                                     } 50 TypeSpecifier (all)
;;;                                                                                                   } 49 TypeName (internal)
        IN   (IN_CLK_CTR_HIGH), RU
;--     l << r
        LSL     RR, #0x0008
;;;                                                                                                 } 48 Expr l << r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
        IN   (IN_CLK_CTR_LOW), RU
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     l | r
        OR      LL, RR
;;;                                                                                               } 47 Expr l | r
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (halt_value)
;--     load_ll_var halt_value = -4(FP), SP at -12 (16 bit)
        MOVE    8(SP), LL
;;;                                                                                               } 47 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                                             } 46 Expr l + r
;--     store_rr_var halt_value = -4(FP), SP at -12
        MOVE    RR, 8(SP)
;;;                                                                                           } 45 Expr l += r
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l += r
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = unsigned int (82000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = halt_total
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr l + r
;;;                                                                                               { 47 Expr l >> r
;;;                                                                                                 { 48 TypeName (internal)
;;;                                                                                                   { 49 TypeSpecifier (all)
;;;                                                                                                     spec = int (80000)
;;;                                                                                                   } 49 TypeSpecifier (all)
;;;                                                                                                 } 48 TypeName (internal)
;;;                                                                                                 { 48 Expression (variable name)
;;;                                                                                                   expr_type = "identifier" (halt_value)
;--     load_rr_var halt_value = -4(FP), SP at -12 (16 bit)
        MOVE    8(SP), RR
;;;                                                                                                 } 48 Expression (variable name)
;--     l >> r
        ASR     RR, #0x0008
;;;                                                                                               } 47 Expr l >> r
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (halt_total)
;--     load_ll_var halt_total = -8(FP), SP at -12 (16 bit)
        MOVE    4(SP), LL
;;;                                                                                               } 47 Expression (variable name)
;--     scale_rr *1
;--     l + r
        ADD     LL, RR
;;;                                                                                             } 46 Expr l + r
;--     store_rr_var halt_total = -8(FP), SP at -12
        MOVE    RR, 4(SP)
;;;                                                                                           } 45 Expr l += r
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                         { 44 ExpressionStatement
;;;                                                                                           { 45 Expr l & r
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = unsigned int (82000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = halt_value
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                             { 46 Expr l & r
;;;                                                                                               { 47 TypeName (internal)
;;;                                                                                                 { 48 TypeSpecifier (all)
;;;                                                                                                   spec = unsigned int (82000)
;;;                                                                                                 } 48 TypeSpecifier (all)
;;;                                                                                               } 47 TypeName (internal)
;;;                                                                                               { 47 Expression (variable name)
;;;                                                                                                 expr_type = "identifier" (halt_value)
;--     load_rr_var halt_value = -4(FP), SP at -12 (16 bit)
        MOVE    8(SP), RR
;;;                                                                                               } 47 Expression (variable name)
;--     l & r
        AND     RR, #0x00FF
;;;                                                                                             } 46 Expr l & r
;--     store_rr_var halt_value = -4(FP), SP at -12
        MOVE    RR, 8(SP)
;;;                                                                                           } 45 Expr l & r
;;;                                                                                         } 44 ExpressionStatement
;;;                                                                                       } 43 List
;--     pop 0 bytes
;;;                                                                                     } 42 CompoundStatement
L37_cont_122:
;;;                                                                                     { 42 Expr l - r
;;;                                                                                       { 43 Expr ++r
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (n)
;--     load_rr_var n = -10(FP), SP at -12 (16 bit)
        MOVE    2(SP), RR
;;;                                                                                         } 44 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var n = -10(FP), SP at -12
        MOVE    RR, 2(SP)
;;;                                                                                       } 43 Expr ++r
;--     l - r
        SUB     RR, #0x0001
;;;                                                                                     } 42 Expr l - r
L37_tst_122:
;;;                                                                                     { 42 Expr l < r
;;;                                                                                       { 43 TypeName (internal)
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                       } 43 TypeName (internal)
;;;                                                                                       { 43 Expression (variable name)
;;;                                                                                         expr_type = "identifier" (n)
;--     load_rr_var n = -10(FP), SP at -12 (16 bit)
        MOVE    2(SP), RR
;;;                                                                                       } 43 Expression (variable name)
;--     l < r
        SLT     RR, #0x0064
;;;                                                                                     } 42 Expr l < r
;--     branch_true
        JMP     RRNZ, L37_loop_122
L37_brk_123:
;;;                                                                                   } 41 for Statement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = void (10000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = P
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (struct/union)
;;;                                                                                             spec = struct '_semaphore' (800000)
;;;                                                                                             name = _semaphore
;;;                                                                                           } 45 TypeSpecifier (struct/union)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = sema
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr & r
;--     load_address t3_control
        MOVE    #Ct3_control, RR
;;;                                                                                       } 43 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = void (10000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = P
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (struct/union)
;;;                                                                                             spec = struct '_semaphore' (800000)
;;;                                                                                             name = _semaphore
;;;                                                                                           } 45 TypeSpecifier (struct/union)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = sema
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                       } 43 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = printf
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 Expr (l , r)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (all_total)
;--     load_rr_var all_total = -6(FP), SP at -12 (16 bit)
        MOVE    6(SP), RR
;;;                                                                                         } 44 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 StringExpression
;--     load_rr_string
        MOVE    #Cstr_132, RR
;;;                                                                                         } 44 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                       } 43 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = printf
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 Expr (l , r)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (halt_total)
;--     load_rr_var halt_total = -8(FP), SP at -12 (16 bit)
        MOVE    4(SP), RR
;;;                                                                                         } 44 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 StringExpression
;--     load_rr_string
        MOVE    #Cstr_133, RR
;;;                                                                                         } 44 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                       } 43 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l = r
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = idle
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 Expr l / r
;;;                                                                                         { 44 TypeName (internal)
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                         } 44 TypeName (internal)
;;;                                                                                         { 44 Expr l * r
;;;                                                                                           { 45 TypeName (internal)
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                           } 45 TypeName (internal)
;;;                                                                                           { 45 Expr l >> r
;;;                                                                                             { 46 TypeName (internal)
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = int (80000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                             } 46 TypeName (internal)
;;;                                                                                             { 46 Expression (variable name)
;;;                                                                                               expr_type = "identifier" (halt_total)
;--     load_rr_var halt_total = -8(FP), SP at -12 (16 bit)
        MOVE    4(SP), RR
;;;                                                                                             } 46 Expression (variable name)
;--     l >> r
        ASR     RR, #0x0008
;;;                                                                                           } 45 Expr l >> r
;--     l * r
        MOVE    RR, LL
        MOVE    #0x0064, RR
;--     l * r
        DI
        MUL_IS
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                                         } 44 Expr l * r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                         { 44 Expr l >> r
;;;                                                                                           { 45 TypeName (internal)
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                           } 45 TypeName (internal)
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (all_total)
;--     load_rr_var all_total = -6(FP), SP at -14 (16 bit)
        MOVE    8(SP), RR
;;;                                                                                           } 45 Expression (variable name)
;--     l >> r
        ASR     RR, #0x0008
;;;                                                                                         } 44 Expr l >> r
;--     pop_ll (16 bit)
        MOVE    (SP)+, LL
;--     l / r
        DI
        DIV_IS
        CALL    mult_div
        MD_FIN
        EI
;;;                                                                                       } 43 Expr l / r
;--     store_rr_var idle = -12(FP), SP at -12
        MOVE    RR, 0(SP)
;;;                                                                                     } 42 Expr l = r
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = printf
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 Expr (l , r)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (idle)
;--     load_rr_var idle = -12(FP), SP at -12 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                         } 44 Expression (variable name)
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 StringExpression
;--     load_rr_string
        MOVE    #Cstr_134, RR
;;;                                                                                         } 44 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                       } 43 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = int (80000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = printf
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 Expr (l , r)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expr l - r
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (idle)
;--     load_rr_var idle = -12(FP), SP at -12 (16 bit)
        MOVE    0(SP), RR
;;;                                                                                           } 45 Expression (variable name)
        MOVE    #0x0064, LL
;--     l - r
        SUB     LL, RR
;;;                                                                                         } 44 Expr l - r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = true
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = const char (20100)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = format
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 StringExpression
;--     load_rr_string
        MOVE    #Cstr_135, RR
;;;                                                                                         } 44 StringExpression
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;;;                                                                                       } 43 Expr (l , r)
;--     push 2 bytes
;--     call
        CALL    Cprintf
;--     pop 4 bytes
        ADD     SP, #4
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                   { 41 ExpressionStatement
;;;                                                                                     { 42 Expr l(r)
;;;                                                                                       { 43 TypeName
;;;                                                                                         { 44 TypeSpecifier (all)
;;;                                                                                           spec = void (10000)
;;;                                                                                         } 44 TypeSpecifier (all)
;;;                                                                                         { 44 List
;;;                                                                                           { 45 DeclItem
;;;                                                                                             what = DECL_NAME
;;;                                                                                             name = V
;;;                                                                                           } 45 DeclItem
;;;                                                                                         } 44 List
;;;                                                                                       } 43 TypeName
;;;                                                                                       { 43 ParameterDeclaration
;;;                                                                                         isEllipsis = false
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (struct/union)
;;;                                                                                             spec = struct '_semaphore' (800000)
;;;                                                                                             name = _semaphore
;;;                                                                                           } 45 TypeSpecifier (struct/union)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_POINTER
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 Ptr
;;;                                                                                                 } 48 Ptr
;;;                                                                                               } 47 List
;;;                                                                                             } 46 DeclItem
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = sema
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                       } 43 ParameterDeclaration
;;;                                                                                       { 43 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                       } 43 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                     } 42 Expr l(r)
;;;                                                                                   } 41 ExpressionStatement
;;;                                                                                 } 40 List
;--     pop 0 bytes
;;;                                                                               } 39 CompoundStatement
L37_cont_120:
;--     branch
        JMP     L37_loop_120
L37_brk_121:
;;;                                                                             } 38 for Statement
;;;                                                                           } 37 List
;--     pop 12 bytes
        ADD     SP, #12
;;;                                                                         } 36 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                                         { 36 FunctionDefinition
;;;                                                                           { 37 TypeName
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = void (10000)
;;;                                                                             } 38 TypeSpecifier (all)
;;;                                                                             { 38 List
;;;                                                                               { 39 DeclItem
;;;                                                                                 what = DECL_NAME
;;;                                                                                 name = main_3
;;;                                                                               } 39 DeclItem
;;;                                                                             } 38 List
;;;                                                                           } 37 TypeName
;;;                                                                           { 37 List
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_NAME
;;;                                                                               name = main_3
;;;                                                                             } 38 DeclItem
;;;                                                                             { 38 DeclItem
;;;                                                                               what = DECL_FUN
;;;                                                                             } 38 DeclItem
;;;                                                                           } 37 List
Cmain_3:
;;;                                                                           { 37 CompoundStatement
;;;                                                                             { 38 InitDeclarator
;;;                                                                               { 39 List
;;;                                                                                 { 40 DeclItem
;;;                                                                                   what = DECL_NAME
;;;                                                                                   name = out
;;;                                                                                 } 40 DeclItem
;;;                                                                               } 39 List
;--     push_zero 1 bytes
        CLRB    -(SP)
;;;                                                                             } 38 InitDeclarator
;;;                                                                             { 38 List
;;;                                                                               { 39 ExpressionStatement
        EI
;;;                                                                               } 39 ExpressionStatement
;;;                                                                               { 39 ExpressionStatement
;;;                                                                                 { 40 Expr l(r)
;;;                                                                                   { 41 TypeName
;;;                                                                                     { 42 TypeSpecifier (all)
;;;                                                                                       spec = void (10000)
;;;                                                                                     } 42 TypeSpecifier (all)
;;;                                                                                     { 42 List
;;;                                                                                       { 43 DeclItem
;;;                                                                                         what = DECL_NAME
;;;                                                                                         name = init_stack
;;;                                                                                       } 43 DeclItem
;;;                                                                                     } 42 List
;;;                                                                                   } 41 TypeName
;--     push 0 bytes
;--     call
        CALL    Cinit_stack
;--     pop 0 bytes
;;;                                                                                 } 40 Expr l(r)
;;;                                                                               } 39 ExpressionStatement
;;;                                                                               { 39 for Statement
;;;                                                                                 { 40 ExpressionStatement
;;;                                                                                 } 40 ExpressionStatement
L38_loop_124:
;;;                                                                                 { 40 CompoundStatement
;;;                                                                                   { 41 List
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l(r)
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = void (10000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = P
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = false
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (struct/union)
;;;                                                                                               spec = struct '_semaphore' (800000)
;;;                                                                                               name = _semaphore
;;;                                                                                             } 46 TypeSpecifier (struct/union)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = sema
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expr & r
;--     load_address t3_control
        MOVE    #Ct3_control, RR
;;;                                                                                         } 44 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                       } 43 Expr l(r)
;;;                                                                                     } 42 ExpressionStatement
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l(r)
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = void (10000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = V
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = false
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (struct/union)
;;;                                                                                               spec = struct '_semaphore' (800000)
;;;                                                                                               name = _semaphore
;;;                                                                                             } 46 TypeSpecifier (struct/union)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = sema
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expr & r
;--     load_address t3_control
        MOVE    #Ct3_control, RR
;;;                                                                                         } 44 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                       } 43 Expr l(r)
;;;                                                                                     } 42 ExpressionStatement
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l(r)
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = void (10000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = P
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = false
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (struct/union)
;;;                                                                                               spec = struct '_semaphore' (800000)
;;;                                                                                               name = _semaphore
;;;                                                                                             } 46 TypeSpecifier (struct/union)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = sema
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                         } 44 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CP
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                       } 43 Expr l(r)
;;;                                                                                     } 42 ExpressionStatement
;;;                                                                                     { 42 for Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l = r
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = char (20000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = out
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 NumericExpression (constant 48 = 0x30)
;--     load_rr_constant
        MOVE    #0x0030, RR
;;;                                                                                           } 45 NumericExpression (constant 48 = 0x30)
;--     store_rr_var out = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                                                         } 44 Expr l = r
;;;                                                                                       } 43 ExpressionStatement
;--     branch
        JMP     L38_tst_126
L38_loop_126:
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = putchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = char (20000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = c
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                           } 45 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
L38_cont_126:
;;;                                                                                       { 43 Expr ++r
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                         } 44 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var out = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                                                       } 43 Expr ++r
L38_tst_126:
;;;                                                                                       { 43 Expr l <= r
;;;                                                                                         { 44 TypeName (internal)
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                         } 44 TypeName (internal)
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                         } 44 Expression (variable name)
;--     l <= r
        SLE     RR, #0x0039
;;;                                                                                       } 43 Expr l <= r
;--     branch_true
        JMP     RRNZ, L38_loop_126
L38_brk_127:
;;;                                                                                     } 42 for Statement
;;;                                                                                     { 42 for Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l = r
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = char (20000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = out
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 NumericExpression (constant 65 = 0x41)
;--     load_rr_constant
        MOVE    #0x0041, RR
;;;                                                                                           } 45 NumericExpression (constant 65 = 0x41)
;--     store_rr_var out = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                                                         } 44 Expr l = r
;;;                                                                                       } 43 ExpressionStatement
;--     branch
        JMP     L38_tst_128
L38_loop_128:
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = putchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = char (20000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = c
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                           } 45 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
L38_cont_128:
;;;                                                                                       { 43 Expr ++r
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                         } 44 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var out = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                                                       } 43 Expr ++r
L38_tst_128:
;;;                                                                                       { 43 Expr l <= r
;;;                                                                                         { 44 TypeName (internal)
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                         } 44 TypeName (internal)
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                         } 44 Expression (variable name)
;--     l <= r
        SLE     RR, #0x005A
;;;                                                                                       } 43 Expr l <= r
;--     branch_true
        JMP     RRNZ, L38_loop_128
L38_brk_129:
;;;                                                                                     } 42 for Statement
;;;                                                                                     { 42 for Statement
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l = r
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = char (20000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = out
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 NumericExpression (constant 97 = 0x61)
;--     load_rr_constant
        MOVE    #0x0061, RR
;;;                                                                                           } 45 NumericExpression (constant 97 = 0x61)
;--     store_rr_var out = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                                                         } 44 Expr l = r
;;;                                                                                       } 43 ExpressionStatement
;--     branch
        JMP     L38_tst_130
L38_loop_130:
;;;                                                                                       { 43 ExpressionStatement
;;;                                                                                         { 44 Expr l(r)
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = int (80000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = putchr
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                           { 45 ParameterDeclaration
;;;                                                                                             isEllipsis = false
;;;                                                                                             { 46 TypeName
;;;                                                                                               { 47 TypeSpecifier (all)
;;;                                                                                                 spec = char (20000)
;;;                                                                                               } 47 TypeSpecifier (all)
;;;                                                                                               { 47 List
;;;                                                                                                 { 48 DeclItem
;;;                                                                                                   what = DECL_NAME
;;;                                                                                                   name = c
;;;                                                                                                 } 48 DeclItem
;;;                                                                                               } 47 List
;;;                                                                                             } 46 TypeName
;;;                                                                                           } 45 ParameterDeclaration
;;;                                                                                           { 45 Expression (variable name)
;;;                                                                                             expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                           } 45 Expression (variable name)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                         } 44 Expr l(r)
;;;                                                                                       } 43 ExpressionStatement
L38_cont_130:
;;;                                                                                       { 43 Expr ++r
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                         } 44 Expression (variable name)
;--     ++
        ADD     RR, #0x0001
;--     store_rr_var out = -1(FP), SP at -1
        MOVE    R, 0(SP)
;;;                                                                                       } 43 Expr ++r
L38_tst_130:
;;;                                                                                       { 43 Expr l <= r
;;;                                                                                         { 44 TypeName (internal)
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                         } 44 TypeName (internal)
;;;                                                                                         { 44 Expression (variable name)
;;;                                                                                           expr_type = "identifier" (out)
;--     load_rr_var out = -1(FP), SP at -1 (8 bit)
        MOVE    0(SP), RS
;;;                                                                                         } 44 Expression (variable name)
;--     l <= r
        SLE     RR, #0x007A
;;;                                                                                       } 43 Expr l <= r
;--     branch_true
        JMP     RRNZ, L38_loop_130
L38_brk_131:
;;;                                                                                     } 42 for Statement
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l(r)
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = putchr
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = false
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = char (20000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = c
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 NumericExpression (constant 13 = 0xD)
;--     load_rr_constant
        MOVE    #0x000D, RR
;;;                                                                                         } 44 NumericExpression (constant 13 = 0xD)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                       } 43 Expr l(r)
;;;                                                                                     } 42 ExpressionStatement
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l(r)
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = int (80000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = putchr
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = false
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (all)
;;;                                                                                               spec = char (20000)
;;;                                                                                             } 46 TypeSpecifier (all)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = c
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 NumericExpression (constant 10 = 0xA)
;--     load_rr_constant
        MOVE    #0x000A, RR
;;;                                                                                         } 44 NumericExpression (constant 10 = 0xA)
;--     push_rr (8 bit)
        MOVE    R, -(SP)
;--     push 2 bytes
;--     call
        CALL    Cputchr
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                                       } 43 Expr l(r)
;;;                                                                                     } 42 ExpressionStatement
;;;                                                                                     { 42 ExpressionStatement
;;;                                                                                       { 43 Expr l(r)
;;;                                                                                         { 44 TypeName
;;;                                                                                           { 45 TypeSpecifier (all)
;;;                                                                                             spec = void (10000)
;;;                                                                                           } 45 TypeSpecifier (all)
;;;                                                                                           { 45 List
;;;                                                                                             { 46 DeclItem
;;;                                                                                               what = DECL_NAME
;;;                                                                                               name = V
;;;                                                                                             } 46 DeclItem
;;;                                                                                           } 45 List
;;;                                                                                         } 44 TypeName
;;;                                                                                         { 44 ParameterDeclaration
;;;                                                                                           isEllipsis = false
;;;                                                                                           { 45 TypeName
;;;                                                                                             { 46 TypeSpecifier (struct/union)
;;;                                                                                               spec = struct '_semaphore' (800000)
;;;                                                                                               name = _semaphore
;;;                                                                                             } 46 TypeSpecifier (struct/union)
;;;                                                                                             { 46 List
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_POINTER
;;;                                                                                                 { 48 List
;;;                                                                                                   { 49 Ptr
;;;                                                                                                   } 49 Ptr
;;;                                                                                                 } 48 List
;;;                                                                                               } 47 DeclItem
;;;                                                                                               { 47 DeclItem
;;;                                                                                                 what = DECL_NAME
;;;                                                                                                 name = sema
;;;                                                                                               } 47 DeclItem
;;;                                                                                             } 46 List
;;;                                                                                           } 45 TypeName
;;;                                                                                         } 44 ParameterDeclaration
;;;                                                                                         { 44 Expr & r
;--     load_address serial_out
        MOVE    #Cserial_out, RR
;;;                                                                                         } 44 Expr & r
;--     push_rr (16 bit)
        MOVE    RR, -(SP)
;--     push 0 bytes
;--     call
        CALL    CV
;--     pop 2 bytes
        ADD     SP, #2
;;;                                                                                       } 43 Expr l(r)
;;;                                                                                     } 42 ExpressionStatement
;;;                                                                                   } 41 List
;--     pop 0 bytes
;;;                                                                                 } 40 CompoundStatement
L38_cont_124:
;--     branch
        JMP     L38_loop_124
L38_brk_125:
;;;                                                                               } 39 for Statement
;;;                                                                             } 38 List
;--     pop 1 bytes
        ADD     SP, #1
;;;                                                                           } 37 CompoundStatement
;--     ret
        RET
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = unsigned int (82000)
;;;                                                                             } 38 TypeSpecifier (all)
Cstack_1:                       ;
        .BYTE   0                        ; VOID [0]
        .BYTE   0                        ; VOID [1]
        .BYTE   0                        ; VOID [2]
        .BYTE   0                        ; VOID [3]
        .BYTE   0                        ; VOID [4]
        .BYTE   0                        ; VOID [5]
        .BYTE   0                        ; VOID [6]
        .BYTE   0                        ; VOID [7]
        .BYTE   0                        ; VOID [8]
        .BYTE   0                        ; VOID [9]
        .BYTE   0                        ; VOID [10]
        .BYTE   0                        ; VOID [11]
        .BYTE   0                        ; VOID [12]
        .BYTE   0                        ; VOID [13]
        .BYTE   0                        ; VOID [14]
        .BYTE   0                        ; VOID [15]
        .BYTE   0                        ; VOID [16]
        .BYTE   0                        ; VOID [17]
        .BYTE   0                        ; VOID [18]
        .BYTE   0                        ; VOID [19]
        .BYTE   0                        ; VOID [20]
        .BYTE   0                        ; VOID [21]
        .BYTE   0                        ; VOID [22]
        .BYTE   0                        ; VOID [23]
        .BYTE   0                        ; VOID [24]
        .BYTE   0                        ; VOID [25]
        .BYTE   0                        ; VOID [26]
        .BYTE   0                        ; VOID [27]
        .BYTE   0                        ; VOID [28]
        .BYTE   0                        ; VOID [29]
        .BYTE   0                        ; VOID [30]
        .BYTE   0                        ; VOID [31]
        .BYTE   0                        ; VOID [32]
        .BYTE   0                        ; VOID [33]
        .BYTE   0                        ; VOID [34]
        .BYTE   0                        ; VOID [35]
        .BYTE   0                        ; VOID [36]
        .BYTE   0                        ; VOID [37]
        .BYTE   0                        ; VOID [38]
        .BYTE   0                        ; VOID [39]
        .BYTE   0                        ; VOID [40]
        .BYTE   0                        ; VOID [41]
        .BYTE   0                        ; VOID [42]
        .BYTE   0                        ; VOID [43]
        .BYTE   0                        ; VOID [44]
        .BYTE   0                        ; VOID [45]
        .BYTE   0                        ; VOID [46]
        .BYTE   0                        ; VOID [47]
        .BYTE   0                        ; VOID [48]
        .BYTE   0                        ; VOID [49]
        .BYTE   0                        ; VOID [50]
        .BYTE   0                        ; VOID [51]
        .BYTE   0                        ; VOID [52]
        .BYTE   0                        ; VOID [53]
        .BYTE   0                        ; VOID [54]
        .BYTE   0                        ; VOID [55]
        .BYTE   0                        ; VOID [56]
        .BYTE   0                        ; VOID [57]
        .BYTE   0                        ; VOID [58]
        .BYTE   0                        ; VOID [59]
        .BYTE   0                        ; VOID [60]
        .BYTE   0                        ; VOID [61]
        .BYTE   0                        ; VOID [62]
        .BYTE   0                        ; VOID [63]
        .BYTE   0                        ; VOID [64]
        .BYTE   0                        ; VOID [65]
        .BYTE   0                        ; VOID [66]
        .BYTE   0                        ; VOID [67]
        .BYTE   0                        ; VOID [68]
        .BYTE   0                        ; VOID [69]
        .BYTE   0                        ; VOID [70]
        .BYTE   0                        ; VOID [71]
        .BYTE   0                        ; VOID [72]
        .BYTE   0                        ; VOID [73]
        .BYTE   0                        ; VOID [74]
        .BYTE   0                        ; VOID [75]
        .BYTE   0                        ; VOID [76]
        .BYTE   0                        ; VOID [77]
        .BYTE   0                        ; VOID [78]
        .BYTE   0                        ; VOID [79]
        .BYTE   0                        ; VOID [80]
        .BYTE   0                        ; VOID [81]
        .BYTE   0                        ; VOID [82]
        .BYTE   0                        ; VOID [83]
        .BYTE   0                        ; VOID [84]
        .BYTE   0                        ; VOID [85]
        .BYTE   0                        ; VOID [86]
        .BYTE   0                        ; VOID [87]
        .BYTE   0                        ; VOID [88]
        .BYTE   0                        ; VOID [89]
        .BYTE   0                        ; VOID [90]
        .BYTE   0                        ; VOID [91]
        .BYTE   0                        ; VOID [92]
        .BYTE   0                        ; VOID [93]
        .BYTE   0                        ; VOID [94]
        .BYTE   0                        ; VOID [95]
        .BYTE   0                        ; VOID [96]
        .BYTE   0                        ; VOID [97]
        .BYTE   0                        ; VOID [98]
        .BYTE   0                        ; VOID [99]
        .BYTE   0                        ; VOID [100]
        .BYTE   0                        ; VOID [101]
        .BYTE   0                        ; VOID [102]
        .BYTE   0                        ; VOID [103]
        .BYTE   0                        ; VOID [104]
        .BYTE   0                        ; VOID [105]
        .BYTE   0                        ; VOID [106]
        .BYTE   0                        ; VOID [107]
        .BYTE   0                        ; VOID [108]
        .BYTE   0                        ; VOID [109]
        .BYTE   0                        ; VOID [110]
        .BYTE   0                        ; VOID [111]
        .BYTE   0                        ; VOID [112]
        .BYTE   0                        ; VOID [113]
        .BYTE   0                        ; VOID [114]
        .BYTE   0                        ; VOID [115]
        .BYTE   0                        ; VOID [116]
        .BYTE   0                        ; VOID [117]
        .BYTE   0                        ; VOID [118]
        .BYTE   0                        ; VOID [119]
        .BYTE   0                        ; VOID [120]
        .BYTE   0                        ; VOID [121]
        .BYTE   0                        ; VOID [122]
        .BYTE   0                        ; VOID [123]
        .BYTE   0                        ; VOID [124]
        .BYTE   0                        ; VOID [125]
        .BYTE   0                        ; VOID [126]
        .BYTE   0                        ; VOID [127]
        .BYTE   0                        ; VOID [128]
        .BYTE   0                        ; VOID [129]
        .BYTE   0                        ; VOID [130]
        .BYTE   0                        ; VOID [131]
        .BYTE   0                        ; VOID [132]
        .BYTE   0                        ; VOID [133]
        .BYTE   0                        ; VOID [134]
        .BYTE   0                        ; VOID [135]
        .BYTE   0                        ; VOID [136]
        .BYTE   0                        ; VOID [137]
        .BYTE   0                        ; VOID [138]
        .BYTE   0                        ; VOID [139]
        .BYTE   0                        ; VOID [140]
        .BYTE   0                        ; VOID [141]
        .BYTE   0                        ; VOID [142]
        .BYTE   0                        ; VOID [143]
        .BYTE   0                        ; VOID [144]
        .BYTE   0                        ; VOID [145]
        .BYTE   0                        ; VOID [146]
        .BYTE   0                        ; VOID [147]
        .BYTE   0                        ; VOID [148]
        .BYTE   0                        ; VOID [149]
        .BYTE   0                        ; VOID [150]
        .BYTE   0                        ; VOID [151]
        .BYTE   0                        ; VOID [152]
        .BYTE   0                        ; VOID [153]
        .BYTE   0                        ; VOID [154]
        .BYTE   0                        ; VOID [155]
        .BYTE   0                        ; VOID [156]
        .BYTE   0                        ; VOID [157]
        .BYTE   0                        ; VOID [158]
        .BYTE   0                        ; VOID [159]
        .BYTE   0                        ; VOID [160]
        .BYTE   0                        ; VOID [161]
        .BYTE   0                        ; VOID [162]
        .BYTE   0                        ; VOID [163]
        .BYTE   0                        ; VOID [164]
        .BYTE   0                        ; VOID [165]
        .BYTE   0                        ; VOID [166]
        .BYTE   0                        ; VOID [167]
        .BYTE   0                        ; VOID [168]
        .BYTE   0                        ; VOID [169]
        .BYTE   0                        ; VOID [170]
        .BYTE   0                        ; VOID [171]
        .BYTE   0                        ; VOID [172]
        .BYTE   0                        ; VOID [173]
        .BYTE   0                        ; VOID [174]
        .BYTE   0                        ; VOID [175]
        .BYTE   0                        ; VOID [176]
        .BYTE   0                        ; VOID [177]
        .BYTE   0                        ; VOID [178]
        .BYTE   0                        ; VOID [179]
        .BYTE   0                        ; VOID [180]
        .BYTE   0                        ; VOID [181]
        .BYTE   0                        ; VOID [182]
        .BYTE   0                        ; VOID [183]
        .BYTE   0                        ; VOID [184]
        .BYTE   0                        ; VOID [185]
        .BYTE   0                        ; VOID [186]
        .BYTE   0                        ; VOID [187]
        .BYTE   0                        ; VOID [188]
        .BYTE   0                        ; VOID [189]
        .BYTE   0                        ; VOID [190]
        .BYTE   0                        ; VOID [191]
        .BYTE   0                        ; VOID [192]
        .BYTE   0                        ; VOID [193]
        .BYTE   0                        ; VOID [194]
        .BYTE   0                        ; VOID [195]
        .BYTE   0                        ; VOID [196]
        .BYTE   0                        ; VOID [197]
        .BYTE   0                        ; VOID [198]
        .BYTE   0                        ; VOID [199]
        .BYTE   0                        ; VOID [200]
        .BYTE   0                        ; VOID [201]
        .BYTE   0                        ; VOID [202]
        .BYTE   0                        ; VOID [203]
        .BYTE   0                        ; VOID [204]
        .BYTE   0                        ; VOID [205]
        .BYTE   0                        ; VOID [206]
        .BYTE   0                        ; VOID [207]
        .BYTE   0                        ; VOID [208]
        .BYTE   0                        ; VOID [209]
        .BYTE   0                        ; VOID [210]
        .BYTE   0                        ; VOID [211]
        .BYTE   0                        ; VOID [212]
        .BYTE   0                        ; VOID [213]
        .BYTE   0                        ; VOID [214]
        .BYTE   0                        ; VOID [215]
        .BYTE   0                        ; VOID [216]
        .BYTE   0                        ; VOID [217]
        .BYTE   0                        ; VOID [218]
        .BYTE   0                        ; VOID [219]
        .BYTE   0                        ; VOID [220]
        .BYTE   0                        ; VOID [221]
        .BYTE   0                        ; VOID [222]
        .BYTE   0                        ; VOID [223]
        .BYTE   0                        ; VOID [224]
        .BYTE   0                        ; VOID [225]
        .BYTE   0                        ; VOID [226]
        .BYTE   0                        ; VOID [227]
        .BYTE   0                        ; VOID [228]
        .BYTE   0                        ; VOID [229]
        .BYTE   0                        ; VOID [230]
        .BYTE   0                        ; VOID [231]
        .BYTE   0                        ; VOID [232]
        .BYTE   0                        ; VOID [233]
        .BYTE   0                        ; VOID [234]
        .BYTE   0                        ; VOID [235]
        .BYTE   0                        ; VOID [236]
        .BYTE   0                        ; VOID [237]
        .BYTE   0                        ; VOID [238]
        .BYTE   0                        ; VOID [239]
        .BYTE   0                        ; VOID [240]
        .BYTE   0                        ; VOID [241]
        .BYTE   0                        ; VOID [242]
        .BYTE   0                        ; VOID [243]
        .BYTE   0                        ; VOID [244]
        .BYTE   0                        ; VOID [245]
        .BYTE   0                        ; VOID [246]
        .BYTE   0                        ; VOID [247]
        .BYTE   0                        ; VOID [248]
        .BYTE   0                        ; VOID [249]
        .BYTE   0                        ; VOID [250]
        .BYTE   0                        ; VOID [251]
        .BYTE   0                        ; VOID [252]
        .BYTE   0                        ; VOID [253]
        .BYTE   0                        ; VOID [254]
        .BYTE   0                        ; VOID [255]
        .BYTE   0                        ; VOID [256]
        .BYTE   0                        ; VOID [257]
        .BYTE   0                        ; VOID [258]
        .BYTE   0                        ; VOID [259]
        .BYTE   0                        ; VOID [260]
        .BYTE   0                        ; VOID [261]
        .BYTE   0                        ; VOID [262]
        .BYTE   0                        ; VOID [263]
        .BYTE   0                        ; VOID [264]
        .BYTE   0                        ; VOID [265]
        .BYTE   0                        ; VOID [266]
        .BYTE   0                        ; VOID [267]
        .BYTE   0                        ; VOID [268]
        .BYTE   0                        ; VOID [269]
        .BYTE   0                        ; VOID [270]
        .BYTE   0                        ; VOID [271]
        .BYTE   0                        ; VOID [272]
        .BYTE   0                        ; VOID [273]
        .BYTE   0                        ; VOID [274]
        .BYTE   0                        ; VOID [275]
        .BYTE   0                        ; VOID [276]
        .BYTE   0                        ; VOID [277]
        .BYTE   0                        ; VOID [278]
        .BYTE   0                        ; VOID [279]
        .BYTE   0                        ; VOID [280]
        .BYTE   0                        ; VOID [281]
        .BYTE   0                        ; VOID [282]
        .BYTE   0                        ; VOID [283]
        .BYTE   0                        ; VOID [284]
        .BYTE   0                        ; VOID [285]
        .BYTE   0                        ; VOID [286]
        .BYTE   0                        ; VOID [287]
        .BYTE   0                        ; VOID [288]
        .BYTE   0                        ; VOID [289]
        .BYTE   0                        ; VOID [290]
        .BYTE   0                        ; VOID [291]
        .BYTE   0                        ; VOID [292]
        .BYTE   0                        ; VOID [293]
        .BYTE   0                        ; VOID [294]
        .BYTE   0                        ; VOID [295]
        .BYTE   0                        ; VOID [296]
        .BYTE   0                        ; VOID [297]
        .BYTE   0                        ; VOID [298]
        .BYTE   0                        ; VOID [299]
        .BYTE   0                        ; VOID [300]
        .BYTE   0                        ; VOID [301]
        .BYTE   0                        ; VOID [302]
        .BYTE   0                        ; VOID [303]
        .BYTE   0                        ; VOID [304]
        .BYTE   0                        ; VOID [305]
        .BYTE   0                        ; VOID [306]
        .BYTE   0                        ; VOID [307]
        .BYTE   0                        ; VOID [308]
        .BYTE   0                        ; VOID [309]
        .BYTE   0                        ; VOID [310]
        .BYTE   0                        ; VOID [311]
        .BYTE   0                        ; VOID [312]
        .BYTE   0                        ; VOID [313]
        .BYTE   0                        ; VOID [314]
        .BYTE   0                        ; VOID [315]
        .BYTE   0                        ; VOID [316]
        .BYTE   0                        ; VOID [317]
        .BYTE   0                        ; VOID [318]
        .BYTE   0                        ; VOID [319]
        .BYTE   0                        ; VOID [320]
        .BYTE   0                        ; VOID [321]
        .BYTE   0                        ; VOID [322]
        .BYTE   0                        ; VOID [323]
        .BYTE   0                        ; VOID [324]
        .BYTE   0                        ; VOID [325]
        .BYTE   0                        ; VOID [326]
        .BYTE   0                        ; VOID [327]
        .BYTE   0                        ; VOID [328]
        .BYTE   0                        ; VOID [329]
        .BYTE   0                        ; VOID [330]
        .BYTE   0                        ; VOID [331]
        .BYTE   0                        ; VOID [332]
        .BYTE   0                        ; VOID [333]
        .BYTE   0                        ; VOID [334]
        .BYTE   0                        ; VOID [335]
        .BYTE   0                        ; VOID [336]
        .BYTE   0                        ; VOID [337]
        .BYTE   0                        ; VOID [338]
        .BYTE   0                        ; VOID [339]
        .BYTE   0                        ; VOID [340]
        .BYTE   0                        ; VOID [341]
        .BYTE   0                        ; VOID [342]
        .BYTE   0                        ; VOID [343]
        .BYTE   0                        ; VOID [344]
        .BYTE   0                        ; VOID [345]
        .BYTE   0                        ; VOID [346]
        .BYTE   0                        ; VOID [347]
        .BYTE   0                        ; VOID [348]
        .BYTE   0                        ; VOID [349]
        .BYTE   0                        ; VOID [350]
        .BYTE   0                        ; VOID [351]
        .BYTE   0                        ; VOID [352]
        .BYTE   0                        ; VOID [353]
        .BYTE   0                        ; VOID [354]
        .BYTE   0                        ; VOID [355]
        .BYTE   0                        ; VOID [356]
        .BYTE   0                        ; VOID [357]
        .BYTE   0                        ; VOID [358]
        .BYTE   0                        ; VOID [359]
        .BYTE   0                        ; VOID [360]
        .BYTE   0                        ; VOID [361]
        .BYTE   0                        ; VOID [362]
        .BYTE   0                        ; VOID [363]
        .BYTE   0                        ; VOID [364]
        .BYTE   0                        ; VOID [365]
        .BYTE   0                        ; VOID [366]
        .BYTE   0                        ; VOID [367]
        .BYTE   0                        ; VOID [368]
        .BYTE   0                        ; VOID [369]
        .BYTE   0                        ; VOID [370]
        .BYTE   0                        ; VOID [371]
        .BYTE   0                        ; VOID [372]
        .BYTE   0                        ; VOID [373]
        .BYTE   0                        ; VOID [374]
        .BYTE   0                        ; VOID [375]
        .BYTE   0                        ; VOID [376]
        .BYTE   0                        ; VOID [377]
        .BYTE   0                        ; VOID [378]
        .BYTE   0                        ; VOID [379]
        .BYTE   0                        ; VOID [380]
        .BYTE   0                        ; VOID [381]
        .BYTE   0                        ; VOID [382]
        .BYTE   0                        ; VOID [383]
        .BYTE   0                        ; VOID [384]
        .BYTE   0                        ; VOID [385]
        .BYTE   0                        ; VOID [386]
        .BYTE   0                        ; VOID [387]
        .BYTE   0                        ; VOID [388]
        .BYTE   0                        ; VOID [389]
        .BYTE   0                        ; VOID [390]
        .BYTE   0                        ; VOID [391]
        .BYTE   0                        ; VOID [392]
        .BYTE   0                        ; VOID [393]
        .BYTE   0                        ; VOID [394]
        .BYTE   0                        ; VOID [395]
        .BYTE   0                        ; VOID [396]
        .BYTE   0                        ; VOID [397]
        .BYTE   0                        ; VOID [398]
        .BYTE   0                        ; VOID [399]
Ctos_1:                 ;
        .WORD   0
        .WORD   0
        .WORD   Cmain_1                 ; & main_1
Ctop_1:                 ;
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = unsigned int (82000)
;;;                                                                             } 38 TypeSpecifier (all)
Cstack_2:                       ;
        .BYTE   0                        ; VOID [0]
        .BYTE   0                        ; VOID [1]
        .BYTE   0                        ; VOID [2]
        .BYTE   0                        ; VOID [3]
        .BYTE   0                        ; VOID [4]
        .BYTE   0                        ; VOID [5]
        .BYTE   0                        ; VOID [6]
        .BYTE   0                        ; VOID [7]
        .BYTE   0                        ; VOID [8]
        .BYTE   0                        ; VOID [9]
        .BYTE   0                        ; VOID [10]
        .BYTE   0                        ; VOID [11]
        .BYTE   0                        ; VOID [12]
        .BYTE   0                        ; VOID [13]
        .BYTE   0                        ; VOID [14]
        .BYTE   0                        ; VOID [15]
        .BYTE   0                        ; VOID [16]
        .BYTE   0                        ; VOID [17]
        .BYTE   0                        ; VOID [18]
        .BYTE   0                        ; VOID [19]
        .BYTE   0                        ; VOID [20]
        .BYTE   0                        ; VOID [21]
        .BYTE   0                        ; VOID [22]
        .BYTE   0                        ; VOID [23]
        .BYTE   0                        ; VOID [24]
        .BYTE   0                        ; VOID [25]
        .BYTE   0                        ; VOID [26]
        .BYTE   0                        ; VOID [27]
        .BYTE   0                        ; VOID [28]
        .BYTE   0                        ; VOID [29]
        .BYTE   0                        ; VOID [30]
        .BYTE   0                        ; VOID [31]
        .BYTE   0                        ; VOID [32]
        .BYTE   0                        ; VOID [33]
        .BYTE   0                        ; VOID [34]
        .BYTE   0                        ; VOID [35]
        .BYTE   0                        ; VOID [36]
        .BYTE   0                        ; VOID [37]
        .BYTE   0                        ; VOID [38]
        .BYTE   0                        ; VOID [39]
        .BYTE   0                        ; VOID [40]
        .BYTE   0                        ; VOID [41]
        .BYTE   0                        ; VOID [42]
        .BYTE   0                        ; VOID [43]
        .BYTE   0                        ; VOID [44]
        .BYTE   0                        ; VOID [45]
        .BYTE   0                        ; VOID [46]
        .BYTE   0                        ; VOID [47]
        .BYTE   0                        ; VOID [48]
        .BYTE   0                        ; VOID [49]
        .BYTE   0                        ; VOID [50]
        .BYTE   0                        ; VOID [51]
        .BYTE   0                        ; VOID [52]
        .BYTE   0                        ; VOID [53]
        .BYTE   0                        ; VOID [54]
        .BYTE   0                        ; VOID [55]
        .BYTE   0                        ; VOID [56]
        .BYTE   0                        ; VOID [57]
        .BYTE   0                        ; VOID [58]
        .BYTE   0                        ; VOID [59]
        .BYTE   0                        ; VOID [60]
        .BYTE   0                        ; VOID [61]
        .BYTE   0                        ; VOID [62]
        .BYTE   0                        ; VOID [63]
        .BYTE   0                        ; VOID [64]
        .BYTE   0                        ; VOID [65]
        .BYTE   0                        ; VOID [66]
        .BYTE   0                        ; VOID [67]
        .BYTE   0                        ; VOID [68]
        .BYTE   0                        ; VOID [69]
        .BYTE   0                        ; VOID [70]
        .BYTE   0                        ; VOID [71]
        .BYTE   0                        ; VOID [72]
        .BYTE   0                        ; VOID [73]
        .BYTE   0                        ; VOID [74]
        .BYTE   0                        ; VOID [75]
        .BYTE   0                        ; VOID [76]
        .BYTE   0                        ; VOID [77]
        .BYTE   0                        ; VOID [78]
        .BYTE   0                        ; VOID [79]
        .BYTE   0                        ; VOID [80]
        .BYTE   0                        ; VOID [81]
        .BYTE   0                        ; VOID [82]
        .BYTE   0                        ; VOID [83]
        .BYTE   0                        ; VOID [84]
        .BYTE   0                        ; VOID [85]
        .BYTE   0                        ; VOID [86]
        .BYTE   0                        ; VOID [87]
        .BYTE   0                        ; VOID [88]
        .BYTE   0                        ; VOID [89]
        .BYTE   0                        ; VOID [90]
        .BYTE   0                        ; VOID [91]
        .BYTE   0                        ; VOID [92]
        .BYTE   0                        ; VOID [93]
        .BYTE   0                        ; VOID [94]
        .BYTE   0                        ; VOID [95]
        .BYTE   0                        ; VOID [96]
        .BYTE   0                        ; VOID [97]
        .BYTE   0                        ; VOID [98]
        .BYTE   0                        ; VOID [99]
        .BYTE   0                        ; VOID [100]
        .BYTE   0                        ; VOID [101]
        .BYTE   0                        ; VOID [102]
        .BYTE   0                        ; VOID [103]
        .BYTE   0                        ; VOID [104]
        .BYTE   0                        ; VOID [105]
        .BYTE   0                        ; VOID [106]
        .BYTE   0                        ; VOID [107]
        .BYTE   0                        ; VOID [108]
        .BYTE   0                        ; VOID [109]
        .BYTE   0                        ; VOID [110]
        .BYTE   0                        ; VOID [111]
        .BYTE   0                        ; VOID [112]
        .BYTE   0                        ; VOID [113]
        .BYTE   0                        ; VOID [114]
        .BYTE   0                        ; VOID [115]
        .BYTE   0                        ; VOID [116]
        .BYTE   0                        ; VOID [117]
        .BYTE   0                        ; VOID [118]
        .BYTE   0                        ; VOID [119]
        .BYTE   0                        ; VOID [120]
        .BYTE   0                        ; VOID [121]
        .BYTE   0                        ; VOID [122]
        .BYTE   0                        ; VOID [123]
        .BYTE   0                        ; VOID [124]
        .BYTE   0                        ; VOID [125]
        .BYTE   0                        ; VOID [126]
        .BYTE   0                        ; VOID [127]
        .BYTE   0                        ; VOID [128]
        .BYTE   0                        ; VOID [129]
        .BYTE   0                        ; VOID [130]
        .BYTE   0                        ; VOID [131]
        .BYTE   0                        ; VOID [132]
        .BYTE   0                        ; VOID [133]
        .BYTE   0                        ; VOID [134]
        .BYTE   0                        ; VOID [135]
        .BYTE   0                        ; VOID [136]
        .BYTE   0                        ; VOID [137]
        .BYTE   0                        ; VOID [138]
        .BYTE   0                        ; VOID [139]
        .BYTE   0                        ; VOID [140]
        .BYTE   0                        ; VOID [141]
        .BYTE   0                        ; VOID [142]
        .BYTE   0                        ; VOID [143]
        .BYTE   0                        ; VOID [144]
        .BYTE   0                        ; VOID [145]
        .BYTE   0                        ; VOID [146]
        .BYTE   0                        ; VOID [147]
        .BYTE   0                        ; VOID [148]
        .BYTE   0                        ; VOID [149]
        .BYTE   0                        ; VOID [150]
        .BYTE   0                        ; VOID [151]
        .BYTE   0                        ; VOID [152]
        .BYTE   0                        ; VOID [153]
        .BYTE   0                        ; VOID [154]
        .BYTE   0                        ; VOID [155]
        .BYTE   0                        ; VOID [156]
        .BYTE   0                        ; VOID [157]
        .BYTE   0                        ; VOID [158]
        .BYTE   0                        ; VOID [159]
        .BYTE   0                        ; VOID [160]
        .BYTE   0                        ; VOID [161]
        .BYTE   0                        ; VOID [162]
        .BYTE   0                        ; VOID [163]
        .BYTE   0                        ; VOID [164]
        .BYTE   0                        ; VOID [165]
        .BYTE   0                        ; VOID [166]
        .BYTE   0                        ; VOID [167]
        .BYTE   0                        ; VOID [168]
        .BYTE   0                        ; VOID [169]
        .BYTE   0                        ; VOID [170]
        .BYTE   0                        ; VOID [171]
        .BYTE   0                        ; VOID [172]
        .BYTE   0                        ; VOID [173]
        .BYTE   0                        ; VOID [174]
        .BYTE   0                        ; VOID [175]
        .BYTE   0                        ; VOID [176]
        .BYTE   0                        ; VOID [177]
        .BYTE   0                        ; VOID [178]
        .BYTE   0                        ; VOID [179]
        .BYTE   0                        ; VOID [180]
        .BYTE   0                        ; VOID [181]
        .BYTE   0                        ; VOID [182]
        .BYTE   0                        ; VOID [183]
        .BYTE   0                        ; VOID [184]
        .BYTE   0                        ; VOID [185]
        .BYTE   0                        ; VOID [186]
        .BYTE   0                        ; VOID [187]
        .BYTE   0                        ; VOID [188]
        .BYTE   0                        ; VOID [189]
        .BYTE   0                        ; VOID [190]
        .BYTE   0                        ; VOID [191]
        .BYTE   0                        ; VOID [192]
        .BYTE   0                        ; VOID [193]
        .BYTE   0                        ; VOID [194]
        .BYTE   0                        ; VOID [195]
        .BYTE   0                        ; VOID [196]
        .BYTE   0                        ; VOID [197]
        .BYTE   0                        ; VOID [198]
        .BYTE   0                        ; VOID [199]
        .BYTE   0                        ; VOID [200]
        .BYTE   0                        ; VOID [201]
        .BYTE   0                        ; VOID [202]
        .BYTE   0                        ; VOID [203]
        .BYTE   0                        ; VOID [204]
        .BYTE   0                        ; VOID [205]
        .BYTE   0                        ; VOID [206]
        .BYTE   0                        ; VOID [207]
        .BYTE   0                        ; VOID [208]
        .BYTE   0                        ; VOID [209]
        .BYTE   0                        ; VOID [210]
        .BYTE   0                        ; VOID [211]
        .BYTE   0                        ; VOID [212]
        .BYTE   0                        ; VOID [213]
        .BYTE   0                        ; VOID [214]
        .BYTE   0                        ; VOID [215]
        .BYTE   0                        ; VOID [216]
        .BYTE   0                        ; VOID [217]
        .BYTE   0                        ; VOID [218]
        .BYTE   0                        ; VOID [219]
        .BYTE   0                        ; VOID [220]
        .BYTE   0                        ; VOID [221]
        .BYTE   0                        ; VOID [222]
        .BYTE   0                        ; VOID [223]
        .BYTE   0                        ; VOID [224]
        .BYTE   0                        ; VOID [225]
        .BYTE   0                        ; VOID [226]
        .BYTE   0                        ; VOID [227]
        .BYTE   0                        ; VOID [228]
        .BYTE   0                        ; VOID [229]
        .BYTE   0                        ; VOID [230]
        .BYTE   0                        ; VOID [231]
        .BYTE   0                        ; VOID [232]
        .BYTE   0                        ; VOID [233]
        .BYTE   0                        ; VOID [234]
        .BYTE   0                        ; VOID [235]
        .BYTE   0                        ; VOID [236]
        .BYTE   0                        ; VOID [237]
        .BYTE   0                        ; VOID [238]
        .BYTE   0                        ; VOID [239]
        .BYTE   0                        ; VOID [240]
        .BYTE   0                        ; VOID [241]
        .BYTE   0                        ; VOID [242]
        .BYTE   0                        ; VOID [243]
        .BYTE   0                        ; VOID [244]
        .BYTE   0                        ; VOID [245]
        .BYTE   0                        ; VOID [246]
        .BYTE   0                        ; VOID [247]
        .BYTE   0                        ; VOID [248]
        .BYTE   0                        ; VOID [249]
        .BYTE   0                        ; VOID [250]
        .BYTE   0                        ; VOID [251]
        .BYTE   0                        ; VOID [252]
        .BYTE   0                        ; VOID [253]
        .BYTE   0                        ; VOID [254]
        .BYTE   0                        ; VOID [255]
        .BYTE   0                        ; VOID [256]
        .BYTE   0                        ; VOID [257]
        .BYTE   0                        ; VOID [258]
        .BYTE   0                        ; VOID [259]
        .BYTE   0                        ; VOID [260]
        .BYTE   0                        ; VOID [261]
        .BYTE   0                        ; VOID [262]
        .BYTE   0                        ; VOID [263]
        .BYTE   0                        ; VOID [264]
        .BYTE   0                        ; VOID [265]
        .BYTE   0                        ; VOID [266]
        .BYTE   0                        ; VOID [267]
        .BYTE   0                        ; VOID [268]
        .BYTE   0                        ; VOID [269]
        .BYTE   0                        ; VOID [270]
        .BYTE   0                        ; VOID [271]
        .BYTE   0                        ; VOID [272]
        .BYTE   0                        ; VOID [273]
        .BYTE   0                        ; VOID [274]
        .BYTE   0                        ; VOID [275]
        .BYTE   0                        ; VOID [276]
        .BYTE   0                        ; VOID [277]
        .BYTE   0                        ; VOID [278]
        .BYTE   0                        ; VOID [279]
        .BYTE   0                        ; VOID [280]
        .BYTE   0                        ; VOID [281]
        .BYTE   0                        ; VOID [282]
        .BYTE   0                        ; VOID [283]
        .BYTE   0                        ; VOID [284]
        .BYTE   0                        ; VOID [285]
        .BYTE   0                        ; VOID [286]
        .BYTE   0                        ; VOID [287]
        .BYTE   0                        ; VOID [288]
        .BYTE   0                        ; VOID [289]
        .BYTE   0                        ; VOID [290]
        .BYTE   0                        ; VOID [291]
        .BYTE   0                        ; VOID [292]
        .BYTE   0                        ; VOID [293]
        .BYTE   0                        ; VOID [294]
        .BYTE   0                        ; VOID [295]
        .BYTE   0                        ; VOID [296]
        .BYTE   0                        ; VOID [297]
        .BYTE   0                        ; VOID [298]
        .BYTE   0                        ; VOID [299]
        .BYTE   0                        ; VOID [300]
        .BYTE   0                        ; VOID [301]
        .BYTE   0                        ; VOID [302]
        .BYTE   0                        ; VOID [303]
        .BYTE   0                        ; VOID [304]
        .BYTE   0                        ; VOID [305]
        .BYTE   0                        ; VOID [306]
        .BYTE   0                        ; VOID [307]
        .BYTE   0                        ; VOID [308]
        .BYTE   0                        ; VOID [309]
        .BYTE   0                        ; VOID [310]
        .BYTE   0                        ; VOID [311]
        .BYTE   0                        ; VOID [312]
        .BYTE   0                        ; VOID [313]
        .BYTE   0                        ; VOID [314]
        .BYTE   0                        ; VOID [315]
        .BYTE   0                        ; VOID [316]
        .BYTE   0                        ; VOID [317]
        .BYTE   0                        ; VOID [318]
        .BYTE   0                        ; VOID [319]
        .BYTE   0                        ; VOID [320]
        .BYTE   0                        ; VOID [321]
        .BYTE   0                        ; VOID [322]
        .BYTE   0                        ; VOID [323]
        .BYTE   0                        ; VOID [324]
        .BYTE   0                        ; VOID [325]
        .BYTE   0                        ; VOID [326]
        .BYTE   0                        ; VOID [327]
        .BYTE   0                        ; VOID [328]
        .BYTE   0                        ; VOID [329]
        .BYTE   0                        ; VOID [330]
        .BYTE   0                        ; VOID [331]
        .BYTE   0                        ; VOID [332]
        .BYTE   0                        ; VOID [333]
        .BYTE   0                        ; VOID [334]
        .BYTE   0                        ; VOID [335]
        .BYTE   0                        ; VOID [336]
        .BYTE   0                        ; VOID [337]
        .BYTE   0                        ; VOID [338]
        .BYTE   0                        ; VOID [339]
        .BYTE   0                        ; VOID [340]
        .BYTE   0                        ; VOID [341]
        .BYTE   0                        ; VOID [342]
        .BYTE   0                        ; VOID [343]
        .BYTE   0                        ; VOID [344]
        .BYTE   0                        ; VOID [345]
        .BYTE   0                        ; VOID [346]
        .BYTE   0                        ; VOID [347]
        .BYTE   0                        ; VOID [348]
        .BYTE   0                        ; VOID [349]
        .BYTE   0                        ; VOID [350]
        .BYTE   0                        ; VOID [351]
        .BYTE   0                        ; VOID [352]
        .BYTE   0                        ; VOID [353]
        .BYTE   0                        ; VOID [354]
        .BYTE   0                        ; VOID [355]
        .BYTE   0                        ; VOID [356]
        .BYTE   0                        ; VOID [357]
        .BYTE   0                        ; VOID [358]
        .BYTE   0                        ; VOID [359]
        .BYTE   0                        ; VOID [360]
        .BYTE   0                        ; VOID [361]
        .BYTE   0                        ; VOID [362]
        .BYTE   0                        ; VOID [363]
        .BYTE   0                        ; VOID [364]
        .BYTE   0                        ; VOID [365]
        .BYTE   0                        ; VOID [366]
        .BYTE   0                        ; VOID [367]
        .BYTE   0                        ; VOID [368]
        .BYTE   0                        ; VOID [369]
        .BYTE   0                        ; VOID [370]
        .BYTE   0                        ; VOID [371]
        .BYTE   0                        ; VOID [372]
        .BYTE   0                        ; VOID [373]
        .BYTE   0                        ; VOID [374]
        .BYTE   0                        ; VOID [375]
        .BYTE   0                        ; VOID [376]
        .BYTE   0                        ; VOID [377]
        .BYTE   0                        ; VOID [378]
        .BYTE   0                        ; VOID [379]
        .BYTE   0                        ; VOID [380]
        .BYTE   0                        ; VOID [381]
        .BYTE   0                        ; VOID [382]
        .BYTE   0                        ; VOID [383]
        .BYTE   0                        ; VOID [384]
        .BYTE   0                        ; VOID [385]
        .BYTE   0                        ; VOID [386]
        .BYTE   0                        ; VOID [387]
        .BYTE   0                        ; VOID [388]
        .BYTE   0                        ; VOID [389]
        .BYTE   0                        ; VOID [390]
        .BYTE   0                        ; VOID [391]
        .BYTE   0                        ; VOID [392]
        .BYTE   0                        ; VOID [393]
        .BYTE   0                        ; VOID [394]
        .BYTE   0                        ; VOID [395]
        .BYTE   0                        ; VOID [396]
        .BYTE   0                        ; VOID [397]
        .BYTE   0                        ; VOID [398]
        .BYTE   0                        ; VOID [399]
Ctos_2:                 ;
        .WORD   0
        .WORD   0
        .WORD   Cmain_2                 ; & main_2
Ctop_2:                 ;
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (all)
;;;                                                                               spec = unsigned int (82000)
;;;                                                                             } 38 TypeSpecifier (all)
Cstack_3:                       ;
        .BYTE   0                        ; VOID [0]
        .BYTE   0                        ; VOID [1]
        .BYTE   0                        ; VOID [2]
        .BYTE   0                        ; VOID [3]
        .BYTE   0                        ; VOID [4]
        .BYTE   0                        ; VOID [5]
        .BYTE   0                        ; VOID [6]
        .BYTE   0                        ; VOID [7]
        .BYTE   0                        ; VOID [8]
        .BYTE   0                        ; VOID [9]
        .BYTE   0                        ; VOID [10]
        .BYTE   0                        ; VOID [11]
        .BYTE   0                        ; VOID [12]
        .BYTE   0                        ; VOID [13]
        .BYTE   0                        ; VOID [14]
        .BYTE   0                        ; VOID [15]
        .BYTE   0                        ; VOID [16]
        .BYTE   0                        ; VOID [17]
        .BYTE   0                        ; VOID [18]
        .BYTE   0                        ; VOID [19]
        .BYTE   0                        ; VOID [20]
        .BYTE   0                        ; VOID [21]
        .BYTE   0                        ; VOID [22]
        .BYTE   0                        ; VOID [23]
        .BYTE   0                        ; VOID [24]
        .BYTE   0                        ; VOID [25]
        .BYTE   0                        ; VOID [26]
        .BYTE   0                        ; VOID [27]
        .BYTE   0                        ; VOID [28]
        .BYTE   0                        ; VOID [29]
        .BYTE   0                        ; VOID [30]
        .BYTE   0                        ; VOID [31]
        .BYTE   0                        ; VOID [32]
        .BYTE   0                        ; VOID [33]
        .BYTE   0                        ; VOID [34]
        .BYTE   0                        ; VOID [35]
        .BYTE   0                        ; VOID [36]
        .BYTE   0                        ; VOID [37]
        .BYTE   0                        ; VOID [38]
        .BYTE   0                        ; VOID [39]
        .BYTE   0                        ; VOID [40]
        .BYTE   0                        ; VOID [41]
        .BYTE   0                        ; VOID [42]
        .BYTE   0                        ; VOID [43]
        .BYTE   0                        ; VOID [44]
        .BYTE   0                        ; VOID [45]
        .BYTE   0                        ; VOID [46]
        .BYTE   0                        ; VOID [47]
        .BYTE   0                        ; VOID [48]
        .BYTE   0                        ; VOID [49]
        .BYTE   0                        ; VOID [50]
        .BYTE   0                        ; VOID [51]
        .BYTE   0                        ; VOID [52]
        .BYTE   0                        ; VOID [53]
        .BYTE   0                        ; VOID [54]
        .BYTE   0                        ; VOID [55]
        .BYTE   0                        ; VOID [56]
        .BYTE   0                        ; VOID [57]
        .BYTE   0                        ; VOID [58]
        .BYTE   0                        ; VOID [59]
        .BYTE   0                        ; VOID [60]
        .BYTE   0                        ; VOID [61]
        .BYTE   0                        ; VOID [62]
        .BYTE   0                        ; VOID [63]
        .BYTE   0                        ; VOID [64]
        .BYTE   0                        ; VOID [65]
        .BYTE   0                        ; VOID [66]
        .BYTE   0                        ; VOID [67]
        .BYTE   0                        ; VOID [68]
        .BYTE   0                        ; VOID [69]
        .BYTE   0                        ; VOID [70]
        .BYTE   0                        ; VOID [71]
        .BYTE   0                        ; VOID [72]
        .BYTE   0                        ; VOID [73]
        .BYTE   0                        ; VOID [74]
        .BYTE   0                        ; VOID [75]
        .BYTE   0                        ; VOID [76]
        .BYTE   0                        ; VOID [77]
        .BYTE   0                        ; VOID [78]
        .BYTE   0                        ; VOID [79]
        .BYTE   0                        ; VOID [80]
        .BYTE   0                        ; VOID [81]
        .BYTE   0                        ; VOID [82]
        .BYTE   0                        ; VOID [83]
        .BYTE   0                        ; VOID [84]
        .BYTE   0                        ; VOID [85]
        .BYTE   0                        ; VOID [86]
        .BYTE   0                        ; VOID [87]
        .BYTE   0                        ; VOID [88]
        .BYTE   0                        ; VOID [89]
        .BYTE   0                        ; VOID [90]
        .BYTE   0                        ; VOID [91]
        .BYTE   0                        ; VOID [92]
        .BYTE   0                        ; VOID [93]
        .BYTE   0                        ; VOID [94]
        .BYTE   0                        ; VOID [95]
        .BYTE   0                        ; VOID [96]
        .BYTE   0                        ; VOID [97]
        .BYTE   0                        ; VOID [98]
        .BYTE   0                        ; VOID [99]
        .BYTE   0                        ; VOID [100]
        .BYTE   0                        ; VOID [101]
        .BYTE   0                        ; VOID [102]
        .BYTE   0                        ; VOID [103]
        .BYTE   0                        ; VOID [104]
        .BYTE   0                        ; VOID [105]
        .BYTE   0                        ; VOID [106]
        .BYTE   0                        ; VOID [107]
        .BYTE   0                        ; VOID [108]
        .BYTE   0                        ; VOID [109]
        .BYTE   0                        ; VOID [110]
        .BYTE   0                        ; VOID [111]
        .BYTE   0                        ; VOID [112]
        .BYTE   0                        ; VOID [113]
        .BYTE   0                        ; VOID [114]
        .BYTE   0                        ; VOID [115]
        .BYTE   0                        ; VOID [116]
        .BYTE   0                        ; VOID [117]
        .BYTE   0                        ; VOID [118]
        .BYTE   0                        ; VOID [119]
        .BYTE   0                        ; VOID [120]
        .BYTE   0                        ; VOID [121]
        .BYTE   0                        ; VOID [122]
        .BYTE   0                        ; VOID [123]
        .BYTE   0                        ; VOID [124]
        .BYTE   0                        ; VOID [125]
        .BYTE   0                        ; VOID [126]
        .BYTE   0                        ; VOID [127]
        .BYTE   0                        ; VOID [128]
        .BYTE   0                        ; VOID [129]
        .BYTE   0                        ; VOID [130]
        .BYTE   0                        ; VOID [131]
        .BYTE   0                        ; VOID [132]
        .BYTE   0                        ; VOID [133]
        .BYTE   0                        ; VOID [134]
        .BYTE   0                        ; VOID [135]
        .BYTE   0                        ; VOID [136]
        .BYTE   0                        ; VOID [137]
        .BYTE   0                        ; VOID [138]
        .BYTE   0                        ; VOID [139]
        .BYTE   0                        ; VOID [140]
        .BYTE   0                        ; VOID [141]
        .BYTE   0                        ; VOID [142]
        .BYTE   0                        ; VOID [143]
        .BYTE   0                        ; VOID [144]
        .BYTE   0                        ; VOID [145]
        .BYTE   0                        ; VOID [146]
        .BYTE   0                        ; VOID [147]
        .BYTE   0                        ; VOID [148]
        .BYTE   0                        ; VOID [149]
        .BYTE   0                        ; VOID [150]
        .BYTE   0                        ; VOID [151]
        .BYTE   0                        ; VOID [152]
        .BYTE   0                        ; VOID [153]
        .BYTE   0                        ; VOID [154]
        .BYTE   0                        ; VOID [155]
        .BYTE   0                        ; VOID [156]
        .BYTE   0                        ; VOID [157]
        .BYTE   0                        ; VOID [158]
        .BYTE   0                        ; VOID [159]
        .BYTE   0                        ; VOID [160]
        .BYTE   0                        ; VOID [161]
        .BYTE   0                        ; VOID [162]
        .BYTE   0                        ; VOID [163]
        .BYTE   0                        ; VOID [164]
        .BYTE   0                        ; VOID [165]
        .BYTE   0                        ; VOID [166]
        .BYTE   0                        ; VOID [167]
        .BYTE   0                        ; VOID [168]
        .BYTE   0                        ; VOID [169]
        .BYTE   0                        ; VOID [170]
        .BYTE   0                        ; VOID [171]
        .BYTE   0                        ; VOID [172]
        .BYTE   0                        ; VOID [173]
        .BYTE   0                        ; VOID [174]
        .BYTE   0                        ; VOID [175]
        .BYTE   0                        ; VOID [176]
        .BYTE   0                        ; VOID [177]
        .BYTE   0                        ; VOID [178]
        .BYTE   0                        ; VOID [179]
        .BYTE   0                        ; VOID [180]
        .BYTE   0                        ; VOID [181]
        .BYTE   0                        ; VOID [182]
        .BYTE   0                        ; VOID [183]
        .BYTE   0                        ; VOID [184]
        .BYTE   0                        ; VOID [185]
        .BYTE   0                        ; VOID [186]
        .BYTE   0                        ; VOID [187]
        .BYTE   0                        ; VOID [188]
        .BYTE   0                        ; VOID [189]
        .BYTE   0                        ; VOID [190]
        .BYTE   0                        ; VOID [191]
        .BYTE   0                        ; VOID [192]
        .BYTE   0                        ; VOID [193]
        .BYTE   0                        ; VOID [194]
        .BYTE   0                        ; VOID [195]
        .BYTE   0                        ; VOID [196]
        .BYTE   0                        ; VOID [197]
        .BYTE   0                        ; VOID [198]
        .BYTE   0                        ; VOID [199]
        .BYTE   0                        ; VOID [200]
        .BYTE   0                        ; VOID [201]
        .BYTE   0                        ; VOID [202]
        .BYTE   0                        ; VOID [203]
        .BYTE   0                        ; VOID [204]
        .BYTE   0                        ; VOID [205]
        .BYTE   0                        ; VOID [206]
        .BYTE   0                        ; VOID [207]
        .BYTE   0                        ; VOID [208]
        .BYTE   0                        ; VOID [209]
        .BYTE   0                        ; VOID [210]
        .BYTE   0                        ; VOID [211]
        .BYTE   0                        ; VOID [212]
        .BYTE   0                        ; VOID [213]
        .BYTE   0                        ; VOID [214]
        .BYTE   0                        ; VOID [215]
        .BYTE   0                        ; VOID [216]
        .BYTE   0                        ; VOID [217]
        .BYTE   0                        ; VOID [218]
        .BYTE   0                        ; VOID [219]
        .BYTE   0                        ; VOID [220]
        .BYTE   0                        ; VOID [221]
        .BYTE   0                        ; VOID [222]
        .BYTE   0                        ; VOID [223]
        .BYTE   0                        ; VOID [224]
        .BYTE   0                        ; VOID [225]
        .BYTE   0                        ; VOID [226]
        .BYTE   0                        ; VOID [227]
        .BYTE   0                        ; VOID [228]
        .BYTE   0                        ; VOID [229]
        .BYTE   0                        ; VOID [230]
        .BYTE   0                        ; VOID [231]
        .BYTE   0                        ; VOID [232]
        .BYTE   0                        ; VOID [233]
        .BYTE   0                        ; VOID [234]
        .BYTE   0                        ; VOID [235]
        .BYTE   0                        ; VOID [236]
        .BYTE   0                        ; VOID [237]
        .BYTE   0                        ; VOID [238]
        .BYTE   0                        ; VOID [239]
        .BYTE   0                        ; VOID [240]
        .BYTE   0                        ; VOID [241]
        .BYTE   0                        ; VOID [242]
        .BYTE   0                        ; VOID [243]
        .BYTE   0                        ; VOID [244]
        .BYTE   0                        ; VOID [245]
        .BYTE   0                        ; VOID [246]
        .BYTE   0                        ; VOID [247]
        .BYTE   0                        ; VOID [248]
        .BYTE   0                        ; VOID [249]
        .BYTE   0                        ; VOID [250]
        .BYTE   0                        ; VOID [251]
        .BYTE   0                        ; VOID [252]
        .BYTE   0                        ; VOID [253]
        .BYTE   0                        ; VOID [254]
        .BYTE   0                        ; VOID [255]
        .BYTE   0                        ; VOID [256]
        .BYTE   0                        ; VOID [257]
        .BYTE   0                        ; VOID [258]
        .BYTE   0                        ; VOID [259]
        .BYTE   0                        ; VOID [260]
        .BYTE   0                        ; VOID [261]
        .BYTE   0                        ; VOID [262]
        .BYTE   0                        ; VOID [263]
        .BYTE   0                        ; VOID [264]
        .BYTE   0                        ; VOID [265]
        .BYTE   0                        ; VOID [266]
        .BYTE   0                        ; VOID [267]
        .BYTE   0                        ; VOID [268]
        .BYTE   0                        ; VOID [269]
        .BYTE   0                        ; VOID [270]
        .BYTE   0                        ; VOID [271]
        .BYTE   0                        ; VOID [272]
        .BYTE   0                        ; VOID [273]
        .BYTE   0                        ; VOID [274]
        .BYTE   0                        ; VOID [275]
        .BYTE   0                        ; VOID [276]
        .BYTE   0                        ; VOID [277]
        .BYTE   0                        ; VOID [278]
        .BYTE   0                        ; VOID [279]
        .BYTE   0                        ; VOID [280]
        .BYTE   0                        ; VOID [281]
        .BYTE   0                        ; VOID [282]
        .BYTE   0                        ; VOID [283]
        .BYTE   0                        ; VOID [284]
        .BYTE   0                        ; VOID [285]
        .BYTE   0                        ; VOID [286]
        .BYTE   0                        ; VOID [287]
        .BYTE   0                        ; VOID [288]
        .BYTE   0                        ; VOID [289]
        .BYTE   0                        ; VOID [290]
        .BYTE   0                        ; VOID [291]
        .BYTE   0                        ; VOID [292]
        .BYTE   0                        ; VOID [293]
        .BYTE   0                        ; VOID [294]
        .BYTE   0                        ; VOID [295]
        .BYTE   0                        ; VOID [296]
        .BYTE   0                        ; VOID [297]
        .BYTE   0                        ; VOID [298]
        .BYTE   0                        ; VOID [299]
        .BYTE   0                        ; VOID [300]
        .BYTE   0                        ; VOID [301]
        .BYTE   0                        ; VOID [302]
        .BYTE   0                        ; VOID [303]
        .BYTE   0                        ; VOID [304]
        .BYTE   0                        ; VOID [305]
        .BYTE   0                        ; VOID [306]
        .BYTE   0                        ; VOID [307]
        .BYTE   0                        ; VOID [308]
        .BYTE   0                        ; VOID [309]
        .BYTE   0                        ; VOID [310]
        .BYTE   0                        ; VOID [311]
        .BYTE   0                        ; VOID [312]
        .BYTE   0                        ; VOID [313]
        .BYTE   0                        ; VOID [314]
        .BYTE   0                        ; VOID [315]
        .BYTE   0                        ; VOID [316]
        .BYTE   0                        ; VOID [317]
        .BYTE   0                        ; VOID [318]
        .BYTE   0                        ; VOID [319]
        .BYTE   0                        ; VOID [320]
        .BYTE   0                        ; VOID [321]
        .BYTE   0                        ; VOID [322]
        .BYTE   0                        ; VOID [323]
        .BYTE   0                        ; VOID [324]
        .BYTE   0                        ; VOID [325]
        .BYTE   0                        ; VOID [326]
        .BYTE   0                        ; VOID [327]
        .BYTE   0                        ; VOID [328]
        .BYTE   0                        ; VOID [329]
        .BYTE   0                        ; VOID [330]
        .BYTE   0                        ; VOID [331]
        .BYTE   0                        ; VOID [332]
        .BYTE   0                        ; VOID [333]
        .BYTE   0                        ; VOID [334]
        .BYTE   0                        ; VOID [335]
        .BYTE   0                        ; VOID [336]
        .BYTE   0                        ; VOID [337]
        .BYTE   0                        ; VOID [338]
        .BYTE   0                        ; VOID [339]
        .BYTE   0                        ; VOID [340]
        .BYTE   0                        ; VOID [341]
        .BYTE   0                        ; VOID [342]
        .BYTE   0                        ; VOID [343]
        .BYTE   0                        ; VOID [344]
        .BYTE   0                        ; VOID [345]
        .BYTE   0                        ; VOID [346]
        .BYTE   0                        ; VOID [347]
        .BYTE   0                        ; VOID [348]
        .BYTE   0                        ; VOID [349]
        .BYTE   0                        ; VOID [350]
        .BYTE   0                        ; VOID [351]
        .BYTE   0                        ; VOID [352]
        .BYTE   0                        ; VOID [353]
        .BYTE   0                        ; VOID [354]
        .BYTE   0                        ; VOID [355]
        .BYTE   0                        ; VOID [356]
        .BYTE   0                        ; VOID [357]
        .BYTE   0                        ; VOID [358]
        .BYTE   0                        ; VOID [359]
        .BYTE   0                        ; VOID [360]
        .BYTE   0                        ; VOID [361]
        .BYTE   0                        ; VOID [362]
        .BYTE   0                        ; VOID [363]
        .BYTE   0                        ; VOID [364]
        .BYTE   0                        ; VOID [365]
        .BYTE   0                        ; VOID [366]
        .BYTE   0                        ; VOID [367]
        .BYTE   0                        ; VOID [368]
        .BYTE   0                        ; VOID [369]
        .BYTE   0                        ; VOID [370]
        .BYTE   0                        ; VOID [371]
        .BYTE   0                        ; VOID [372]
        .BYTE   0                        ; VOID [373]
        .BYTE   0                        ; VOID [374]
        .BYTE   0                        ; VOID [375]
        .BYTE   0                        ; VOID [376]
        .BYTE   0                        ; VOID [377]
        .BYTE   0                        ; VOID [378]
        .BYTE   0                        ; VOID [379]
        .BYTE   0                        ; VOID [380]
        .BYTE   0                        ; VOID [381]
        .BYTE   0                        ; VOID [382]
        .BYTE   0                        ; VOID [383]
        .BYTE   0                        ; VOID [384]
        .BYTE   0                        ; VOID [385]
        .BYTE   0                        ; VOID [386]
        .BYTE   0                        ; VOID [387]
        .BYTE   0                        ; VOID [388]
        .BYTE   0                        ; VOID [389]
        .BYTE   0                        ; VOID [390]
        .BYTE   0                        ; VOID [391]
        .BYTE   0                        ; VOID [392]
        .BYTE   0                        ; VOID [393]
        .BYTE   0                        ; VOID [394]
        .BYTE   0                        ; VOID [395]
        .BYTE   0                        ; VOID [396]
        .BYTE   0                        ; VOID [397]
        .BYTE   0                        ; VOID [398]
        .BYTE   0                        ; VOID [399]
Ctos_3:                 ;
        .WORD   0
        .WORD   0
        .WORD   Cmain_3                 ; & main_3
Ctop_3:                 ;
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (struct/union)
;;;                                                                               spec = 'Task' (4000000)
;;;                                                                               name = Task
;;;                                                                             } 38 TypeSpecifier (struct/union)
Ctask_3:                        ;
        .WORD   Ctask_idle                      ; & task_idle
        .WORD   Ctos_3
        .BYTE   0
        .BYTE   30
        .WORD   Cstr_137
        .WORD   Cstack_3                        ; & stack_3
        .WORD   Ctop_3                  ; & top_3
        .BYTE   0                        ; VOID sema_ret
        .BYTE   0                        ; VOID saved_priority
        .WORD   0                        ; VOID waiting_for
        .WORD   0                        ; VOID next_waiting_task
        .WORD   0                        ; VOID sleep_count
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (struct/union)
;;;                                                                               spec = 'Task' (4000000)
;;;                                                                               name = Task
;;;                                                                             } 38 TypeSpecifier (struct/union)
Ctask_2:                        ;
        .WORD   Ctask_3                 ; & task_3
        .WORD   Ctos_2
        .BYTE   0
        .BYTE   40
        .WORD   Cstr_138
        .WORD   Cstack_2                        ; & stack_2
        .WORD   Ctop_2                  ; & top_2
        .BYTE   0                        ; VOID sema_ret
        .BYTE   0                        ; VOID saved_priority
        .WORD   0                        ; VOID waiting_for
        .WORD   0                        ; VOID next_waiting_task
        .WORD   0                        ; VOID sleep_count
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (struct/union)
;;;                                                                               spec = 'Task' (4000000)
;;;                                                                               name = Task
;;;                                                                             } 38 TypeSpecifier (struct/union)
Ctask_1:                        ;
        .WORD   Ctask_2                 ; & task_2
        .WORD   Ctos_1
        .BYTE   0
        .BYTE   50
        .WORD   Cstr_139
        .WORD   Cstack_1                        ; & stack_1
        .WORD   Ctop_1                  ; & top_1
        .BYTE   0                        ; VOID sema_ret
        .BYTE   0                        ; VOID saved_priority
        .WORD   0                        ; VOID waiting_for
        .WORD   0                        ; VOID next_waiting_task
        .WORD   0                        ; VOID sleep_count
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (struct/union)
;;;                                                                               spec = 'Task' (4000000)
;;;                                                                               name = Task
;;;                                                                             } 38 TypeSpecifier (struct/union)
Ctask_idle:                     ;
        .WORD   Ctask_1                 ; & task_1
        .WORD   0
        .BYTE   0
        .BYTE   0
        .WORD   Cstr_140
        .WORD   8064
        .WORD   8192
        .BYTE   0                        ; VOID sema_ret
        .BYTE   0                        ; VOID saved_priority
        .WORD   0                        ; VOID waiting_for
        .WORD   0                        ; VOID next_waiting_task
        .WORD   0                        ; VOID sleep_count
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
;;;                                                                           { 37 Declaration
;;;                                                                             { 38 TypeSpecifier (struct/union)
;;;                                                                               spec = 'Task' (4000000)
;;;                                                                               name = Task
;;;                                                                             } 38 TypeSpecifier (struct/union)
Ccurrent_task:                  ;
        .WORD   Ctask_idle                      ; & task_idle
;;;                                                                           } 37 Declaration
;;; ------------------------------------;
Cstr_0:                         ;
        .BYTE   0x72                    ;
        .BYTE   0x78                    ;
        .BYTE   0x5F                    ;
        .BYTE   0x73                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x61                    ;
        .BYTE   0x70                    ;
        .BYTE   0x68                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0                        ;
Cstr_1:                         ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x32                    ;
        .BYTE   0x20                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x74                    ;
        .BYTE   0x72                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6C                    ;
        .BYTE   0                        ;
Cstr_2:                         ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x33                    ;
        .BYTE   0x20                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x74                    ;
        .BYTE   0x72                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6C                    ;
        .BYTE   0                        ;
Cstr_3:                         ;
        .BYTE   0x73                    ;
        .BYTE   0x65                    ;
        .BYTE   0x72                    ;
        .BYTE   0x69                    ;
        .BYTE   0x61                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x75                    ;
        .BYTE   0x74                    ;
        .BYTE   0                        ;
Cstr_4:                         ;
        .BYTE   0x74                    ;
        .BYTE   0x78                    ;
        .BYTE   0x5F                    ;
        .BYTE   0x73                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x61                    ;
        .BYTE   0x70                    ;
        .BYTE   0x68                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0                        ;
Cstr_36:                                ;
        .BYTE   0x30                    ;
        .BYTE   0x31                    ;
        .BYTE   0x32                    ;
        .BYTE   0x33                    ;
        .BYTE   0x34                    ;
        .BYTE   0x35                    ;
        .BYTE   0x36                    ;
        .BYTE   0x37                    ;
        .BYTE   0x38                    ;
        .BYTE   0x39                    ;
        .BYTE   0x41                    ;
        .BYTE   0x42                    ;
        .BYTE   0x43                    ;
        .BYTE   0x44                    ;
        .BYTE   0x45                    ;
        .BYTE   0x46                    ;
        .BYTE   0                        ;
Cstr_37:                                ;
        .BYTE   0x30                    ;
        .BYTE   0x58                    ;
        .BYTE   0                        ;
Cstr_38:                                ;
        .BYTE   0                        ;
Cstr_39:                                ;
        .BYTE   0                        ;
Cstr_40:                                ;
        .BYTE   0                        ;
Cstr_41:                                ;
        .BYTE   0x30                    ;
        .BYTE   0x31                    ;
        .BYTE   0x32                    ;
        .BYTE   0x33                    ;
        .BYTE   0x34                    ;
        .BYTE   0x35                    ;
        .BYTE   0x36                    ;
        .BYTE   0x37                    ;
        .BYTE   0x38                    ;
        .BYTE   0x39                    ;
        .BYTE   0x61                    ;
        .BYTE   0x62                    ;
        .BYTE   0x63                    ;
        .BYTE   0x64                    ;
        .BYTE   0x65                    ;
        .BYTE   0x66                    ;
        .BYTE   0                        ;
Cstr_42:                                ;
        .BYTE   0x30                    ;
        .BYTE   0x78                    ;
        .BYTE   0                        ;
Cstr_44:                                ;
        .BYTE   0x25                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x32                    ;
        .BYTE   0x30                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_45:                                ;
        .BYTE   0x25                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x3E                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_46:                                ;
        .BYTE   0x30                    ;
        .BYTE   0                        ;
Cstr_47:                                ;
        .BYTE   0x6E                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x65                    ;
        .BYTE   0x2E                    ;
        .BYTE   0                        ;
Cstr_48:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_49:                                ;
        .BYTE   0x4C                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x61                    ;
        .BYTE   0x64                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x67                    ;
        .BYTE   0x20                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x61                    ;
        .BYTE   0x67                    ;
        .BYTE   0x65                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_55:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x53                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x61                    ;
        .BYTE   0x70                    ;
        .BYTE   0x68                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x43                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x75                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x74                    ;
        .BYTE   0x20                    ;
        .BYTE   0x57                    ;
        .BYTE   0x61                    ;
        .BYTE   0x69                    ;
        .BYTE   0x74                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x67                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_56:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_57:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_58:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x53                    ;
        .BYTE   0x65                    ;
        .BYTE   0x72                    ;
        .BYTE   0x69                    ;
        .BYTE   0x61                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x20                    ;
        .BYTE   0x4F                    ;
        .BYTE   0x76                    ;
        .BYTE   0x65                    ;
        .BYTE   0x72                    ;
        .BYTE   0x66                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x77                    ;
        .BYTE   0x73                    ;
        .BYTE   0x3A                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x75                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_59:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x54                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x61                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x50                    ;
        .BYTE   0x72                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x50                    ;
        .BYTE   0x43                    ;
        .BYTE   0x20                    ;
        .BYTE   0x53                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x53                    ;
        .BYTE   0x69                    ;
        .BYTE   0x7A                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x55                    ;
        .BYTE   0x73                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x4E                    ;
        .BYTE   0x65                    ;
        .BYTE   0x78                    ;
        .BYTE   0x74                    ;
        .BYTE   0x20                    ;
        .BYTE   0x77                    ;
        .BYTE   0x61                    ;
        .BYTE   0x69                    ;
        .BYTE   0x74                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x67                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x53                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x74                    ;
        .BYTE   0x75                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_61:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_62:                                ;
        .BYTE   0x25                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x31                    ;
        .BYTE   0x36                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x58                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x58                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x35                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x35                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_63:                                ;
        .BYTE   0x25                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x31                    ;
        .BYTE   0x36                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_64:                                ;
        .BYTE   0x6E                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x65                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_65:                                ;
        .BYTE   0x52                    ;
        .BYTE   0x55                    ;
        .BYTE   0x4E                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_66:                                ;
        .BYTE   0x53                    ;
        .BYTE   0x55                    ;
        .BYTE   0x53                    ;
        .BYTE   0x50                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_67:                                ;
        .BYTE   0x53                    ;
        .BYTE   0x4C                    ;
        .BYTE   0x45                    ;
        .BYTE   0x45                    ;
        .BYTE   0x50                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_68:                                ;
        .BYTE   0x42                    ;
        .BYTE   0x4C                    ;
        .BYTE   0x4B                    ;
        .BYTE   0x44                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_69:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_70:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_71:                                ;
        .BYTE   0x55                    ;
        .BYTE   0x70                    ;
        .BYTE   0x74                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x69                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x34                    ;
        .BYTE   0x58                    ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x34                    ;
        .BYTE   0x58                    ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x34                    ;
        .BYTE   0x58                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x65                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x64                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_72:                                ;
        .BYTE   0x25                    ;
        .BYTE   0x34                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x34                    ;
        .BYTE   0x58                    ;
        .BYTE   0x3A                    ;
        .BYTE   0                        ;
Cstr_73:                                ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x32                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x32                    ;
        .BYTE   0x58                    ;
        .BYTE   0                        ;
Cstr_74:                                ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_75:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_83:                                ;
        .BYTE   0x52                    ;
        .BYTE   0x45                    ;
        .BYTE   0x41                    ;
        .BYTE   0x44                    ;
        .BYTE   0x59                    ;
        .BYTE   0x0D                    ;
        .BYTE   0                        ;
Cstr_84:                                ;
        .BYTE   0x25                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x69                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x62                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_85:                                ;
        .BYTE   0x54                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x32                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x69                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_86:                                ;
        .BYTE   0x54                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x33                    ;
        .BYTE   0x20                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x61                    ;
        .BYTE   0x62                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x66                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x20                    ;
        .BYTE   0x31                    ;
        .BYTE   0x30                    ;
        .BYTE   0x30                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_91:                                ;
        .BYTE   0x64                    ;
        .BYTE   0x65                    ;
        .BYTE   0x73                    ;
        .BYTE   0x63                    ;
        .BYTE   0x68                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x75                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x43                    ;
        .BYTE   0x4C                    ;
        .BYTE   0x4B                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x3D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x75                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_92:                                ;
        .BYTE   0x44                    ;
        .BYTE   0x69                    ;
        .BYTE   0x73                    ;
        .BYTE   0x70                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x61                    ;
        .BYTE   0x79                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_93:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_94:                                ;
        .BYTE   0x4C                    ;
        .BYTE   0x45                    ;
        .BYTE   0x44                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_96:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_97:                                ;
        .BYTE   0x4D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x79                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_98:                                ;
        .BYTE   0x20                    ;
        .BYTE   0x56                    ;
        .BYTE   0x61                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x75                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_99:                                ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_100:                               ;
        .BYTE   0x44                    ;
        .BYTE   0x49                    ;
        .BYTE   0x50                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x77                    ;
        .BYTE   0x69                    ;
        .BYTE   0x74                    ;
        .BYTE   0x63                    ;
        .BYTE   0x68                    ;
        .BYTE   0x20                    ;
        .BYTE   0x69                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x30                    ;
        .BYTE   0x78                    ;
        .BYTE   0x25                    ;
        .BYTE   0x58                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_102:                               ;
        .BYTE   0x54                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x70                    ;
        .BYTE   0x65                    ;
        .BYTE   0x72                    ;
        .BYTE   0x61                    ;
        .BYTE   0x74                    ;
        .BYTE   0x75                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x69                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x64                    ;
        .BYTE   0x65                    ;
        .BYTE   0x67                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x65                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x43                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x73                    ;
        .BYTE   0x69                    ;
        .BYTE   0x75                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_104:                               ;
        .BYTE   0x48                    ;
        .BYTE   0x61                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x74                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_107:                               ;
        .BYTE   0x48                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x70                    ;
        .BYTE   0x3A                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x32                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x69                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x32                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x33                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x69                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x33                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x49                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x61                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x61                    ;
        .BYTE   0x67                    ;
        .BYTE   0x65                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x53                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x68                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x77                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x61                    ;
        .BYTE   0x70                    ;
        .BYTE   0x68                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x54                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x68                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x77                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x62                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x75                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x77                    ;
        .BYTE   0x69                    ;
        .BYTE   0x74                    ;
        .BYTE   0x63                    ;
        .BYTE   0x68                    ;
        .BYTE   0x20                    ;
        .BYTE   0x28                    ;
        .BYTE   0x64                    ;
        .BYTE   0x65                    ;
        .BYTE   0x73                    ;
        .BYTE   0x63                    ;
        .BYTE   0x68                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x75                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x65                    ;
        .BYTE   0x29                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x63                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x68                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x77                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x64                    ;
        .BYTE   0x69                    ;
        .BYTE   0x73                    ;
        .BYTE   0x70                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x61                    ;
        .BYTE   0x79                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x79                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x65                    ;
        .BYTE   0x74                    ;
        .BYTE   0x20                    ;
        .BYTE   0x4C                    ;
        .BYTE   0x45                    ;
        .BYTE   0x44                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x64                    ;
        .BYTE   0x69                    ;
        .BYTE   0x66                    ;
        .BYTE   0x79                    ;
        .BYTE   0x20                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x79                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x73                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x61                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x44                    ;
        .BYTE   0x49                    ;
        .BYTE   0x50                    ;
        .BYTE   0x20                    ;
        .BYTE   0x73                    ;
        .BYTE   0x77                    ;
        .BYTE   0x69                    ;
        .BYTE   0x74                    ;
        .BYTE   0x63                    ;
        .BYTE   0x68                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x74                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x61                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x74                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x70                    ;
        .BYTE   0x65                    ;
        .BYTE   0x72                    ;
        .BYTE   0x61                    ;
        .BYTE   0x74                    ;
        .BYTE   0x75                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x48                    ;
        .BYTE   0x20                    ;
        .BYTE   0x2D                    ;
        .BYTE   0x20                    ;
        .BYTE   0x48                    ;
        .BYTE   0x41                    ;
        .BYTE   0x4C                    ;
        .BYTE   0x54                    ;
        .BYTE   0x20                    ;
        .BYTE   0x28                    ;
        .BYTE   0x66                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x76                    ;
        .BYTE   0x65                    ;
        .BYTE   0x72                    ;
        .BYTE   0x29                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_123:                               ;
        .BYTE   0x4D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x75                    ;
        .BYTE   0x72                    ;
        .BYTE   0x69                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x67                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x2E                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_132:                               ;
        .BYTE   0x74                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x74                    ;
        .BYTE   0x61                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x3A                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x63                    ;
        .BYTE   0x79                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x65                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_133:                               ;
        .BYTE   0x68                    ;
        .BYTE   0x61                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x74                    ;
        .BYTE   0x65                    ;
        .BYTE   0x64                    ;
        .BYTE   0x3A                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x63                    ;
        .BYTE   0x79                    ;
        .BYTE   0x63                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x65                    ;
        .BYTE   0x73                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_134:                               ;
        .BYTE   0x69                    ;
        .BYTE   0x64                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x65                    ;
        .BYTE   0x3A                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x25                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_135:                               ;
        .BYTE   0x6C                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x61                    ;
        .BYTE   0x64                    ;
        .BYTE   0x3A                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x25                    ;
        .BYTE   0x25                    ;
        .BYTE   0x0D                    ;
        .BYTE   0x0A                    ;
        .BYTE   0                        ;
Cstr_137:                               ;
        .BYTE   0x4C                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x61                    ;
        .BYTE   0x64                    ;
        .BYTE   0x20                    ;
        .BYTE   0x54                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0x20                    ;
        .BYTE   0                        ;
Cstr_138:                               ;
        .BYTE   0x4D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x75                    ;
        .BYTE   0x72                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6D                    ;
        .BYTE   0x65                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x74                    ;
        .BYTE   0                        ;
Cstr_139:                               ;
        .BYTE   0x4D                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x6E                    ;
        .BYTE   0x69                    ;
        .BYTE   0x74                    ;
        .BYTE   0x6F                    ;
        .BYTE   0x72                    ;
        .BYTE   0                        ;
Cstr_140:                               ;
        .BYTE   0x49                    ;
        .BYTE   0x64                    ;
        .BYTE   0x6C                    ;
        .BYTE   0x65                    ;
        .BYTE   0x20                    ;
        .BYTE   0x54                    ;
        .BYTE   0x61                    ;
        .BYTE   0x73                    ;
        .BYTE   0x6B                    ;
        .BYTE   0                        ;
Cend_text:                              ;
Line No.	Rev	Author	Line
1	2	jsauermann	`IN_RX_DATA = 0x00 ;`
2			`IN_STATUS = 0x01 ;`
3			`IN_TEMPERAT = 0x02 ;`
4			`IN_DIP_SWITCH = 0x03 ;`
5			`IN_CLK_CTR_LOW = 0x05 ;`
6			`IN_CLK_CTR_HIGH = 0x06 ;`
7
8			`MEMTOP =0x2000`
9
10			`OUT_TX_DATA = 0x00 ;`
11			`OUT_LEDS = 0x02 ;`
12			`OUT_INT_MASK = 0x03 ;`
13			`OUT_RESET_TIMER = 0x04 ;`
14			`OUT_START_CLK_CTR = 0x05 ;`
15			`OUT_STOP_CLK_CTR = 0x06 ;`
16			`;---------------------------------------;`
17			`MOVE #MEMTOP, RR ;`
18			`MOVE RR, SP ;`
19			`EI ;`
20			`JMP Cmain ;`
21			`JMP Cinterrupt ;`
22			`;---------------------------------------;`
23			`mult_div: ;`
24			`MD_STP ; 1`
25			`MD_STP ; 2`
26			`MD_STP ; 3`
27			`MD_STP ; 4`
28			`MD_STP ; 5`
29			`MD_STP ; 6`
30			`MD_STP ; 7`
31			`MD_STP ; 8`
32			`MD_STP ; 9`
33			`MD_STP ; 10`
34			`MD_STP ; 11`
35			`MD_STP ; 12`
36			`MD_STP ; 13`
37			`MD_STP ; 14`
38			`MD_STP ; 15`
39			`MD_STP ; 16`
40			`RET ;`
41			`;---------------------------------------;`
42			`;;; { 0 Declaration`
43			`;;; { 1 TypeSpecifier (enum)`
44			`;;; spec = anonymous enum (2000000)`
45			`;;; } 1 TypeSpecifier (enum)`
46			`;;; } 0 Declaration`
47			`;;; ------------------------------------;`
48			`;;; { 0 Declaration`
49			`;;; { 1 TypeSpecifier (struct/union)`
50			`;;; spec = typedef struct '_task' (800001)`
51			`;;; name = _task`
52			`;;; } 1 TypeSpecifier (struct/union)`
53			`;;; } 0 Declaration`
54			`;;; ------------------------------------;`
55			`;;; { 0 Declaration`
56			`;;; { 1 TypeSpecifier (struct/union)`
57			`;;; spec = typedef struct '_semaphore' (800001)`
58			`;;; name = _semaphore`
59			`;;; } 1 TypeSpecifier (struct/union)`
60			`;;; } 0 Declaration`
61			`;;; ------------------------------------;`
62			`;;; { 0 Declaration`
63			`;;; { 1 TypeSpecifier (struct/union)`
64			`;;; spec = struct '_task' (800000)`
65			`;;; name = _task`
66			`;;; } 1 TypeSpecifier (struct/union)`
67			`;;; } 0 Declaration`
68			`;;; ------------------------------------;`
69			`;;; { 0 Declaration`
70			`;;; { 1 TypeSpecifier (struct/union)`
71			`;;; spec = extern 'Task' (4000002)`
72			`;;; name = Task`
73			`;;; } 1 TypeSpecifier (struct/union)`
74			`.EXTERN Ccurrent_task`
75			`;;; } 0 Declaration`
76			`;;; ------------------------------------;`
77			`;;; { 0 Declaration`
78			`;;; { 1 TypeSpecifier (struct/union)`
79			`;;; spec = extern 'Task' (4000002)`
80			`;;; name = Task`
81			`;;; } 1 TypeSpecifier (struct/union)`
82			`.EXTERN Ctask_idle`
83			`;;; } 0 Declaration`
84			`;;; ------------------------------------;`
85			`;;; { 0 Declaration`
86			`;;; { 1 TypeSpecifier (struct/union)`
87			`;;; spec = struct '_semaphore' (800000)`
88			`;;; name = _semaphore`
89			`;;; } 1 TypeSpecifier (struct/union)`
90			`;;; } 0 Declaration`
91			`;;; ------------------------------------;`
92			`;;; { 0 Declaration`
93			`;;; { 1 TypeSpecifier (struct/union)`
94			`;;; spec = 'Semaphore' (4000000)`
95			`;;; name = Semaphore`
96			`;;; } 1 TypeSpecifier (struct/union)`
97			`Crx_sema: ;`
98			`.WORD 0`
99			`.WORD 0`
100			`.WORD 0`
101			`.WORD Cstr_0`
102			`;;; } 0 Declaration`
103			`;;; ------------------------------------;`
104			`;;; { 0 Declaration`
105			`;;; { 1 TypeSpecifier (struct/union)`
106			`;;; spec = 'Semaphore' (4000000)`
107			`;;; name = Semaphore`
108			`;;; } 1 TypeSpecifier (struct/union)`
109			`Ct2_control: ;`
110			`.WORD 0`
111			`.WORD 0`
112			`.WORD 0`
113			`.WORD Cstr_1`
114			`;;; } 0 Declaration`
115			`;;; ------------------------------------;`
116			`;;; { 0 Declaration`
117			`;;; { 1 TypeSpecifier (struct/union)`
118			`;;; spec = 'Semaphore' (4000000)`
119			`;;; name = Semaphore`
120			`;;; } 1 TypeSpecifier (struct/union)`
121			`Ct3_control: ;`
122			`.WORD 0`
123			`.WORD 0`
124			`.WORD 0`
125			`.WORD Cstr_2`
126			`;;; } 0 Declaration`
127			`;;; ------------------------------------;`
128			`;;; { 0 Declaration`
129			`;;; { 1 TypeSpecifier (struct/union)`
130			`;;; spec = 'Semaphore' (4000000)`
131			`;;; name = Semaphore`
132			`;;; } 1 TypeSpecifier (struct/union)`
133			`Cserial_out: ;`
134			`.WORD 1`
135			`.WORD 0`
136			`.WORD 0`
137			`.WORD Cstr_3`
138			`;;; } 0 Declaration`
139			`;;; ------------------------------------;`
140			`;;; { 0 Declaration`
141			`;;; { 1 TypeSpecifier (struct/union)`
142			`;;; spec = 'Semaphore' (4000000)`
143			`;;; name = Semaphore`
144			`;;; } 1 TypeSpecifier (struct/union)`
145			`Ctx_sema: ;`
146			`.WORD 16`
147			`.WORD 0`
148			`.WORD 0`
149			`.WORD Cstr_4`
150			`;;; } 0 Declaration`
151			`;;; ------------------------------------;`
152			`;;; { 0 FunctionDefinition`
153			`;;; { 1 TypeName`
154			`;;; { 2 TypeSpecifier (all)`
155			`;;; spec = void (10000)`
156			`;;; } 2 TypeSpecifier (all)`
157			`;;; { 2 List`
158			`;;; { 3 DeclItem`
159			`;;; what = DECL_NAME`
160			`;;; name = switch_tasks`
161			`;;; } 3 DeclItem`
162			`;;; } 2 List`
163			`;;; } 1 TypeName`
164			`;;; { 1 List`
165			`;;; { 2 DeclItem`
166			`;;; what = DECL_NAME`
167			`;;; name = switch_tasks`
168			`;;; } 2 DeclItem`
169			`;;; { 2 DeclItem`
170			`;;; what = DECL_FUN`
171			`;;; } 2 DeclItem`
172			`;;; } 1 List`
173			`Cswitch_tasks:`
174	7	jsauermann	`;;; { 1 CompoundStatement`
175			`;;; { 2 InitDeclarator`
176			`;;; { 3 List`
177			`;;; { 4 DeclItem`
178			`;;; what = DECL_POINTER`
179			`;;; { 5 List`
180			`;;; { 6 Ptr`
181			`;;; } 6 Ptr`
182			`;;; } 5 List`
183			`;;; } 4 DeclItem`
184			`;;; { 4 DeclItem`
185			`;;; what = DECL_NAME`
186			`;;; name = next`
187			`;;; } 4 DeclItem`
188			`;;; } 3 List`
189			`;;; { 3 Initializer (skalar)`
190	2	jsauermann	`;-- push_zero 2 bytes`
191			`CLRW -(SP)`
192	7	jsauermann	`;;; } 3 Initializer (skalar)`
193			`;;; } 2 InitDeclarator`
194			`;;; { 2 InitDeclarator`
195			`;;; { 3 List`
196			`;;; { 4 DeclItem`
197			`;;; what = DECL_POINTER`
198			`;;; { 5 List`
199			`;;; { 6 Ptr`
200			`;;; } 6 Ptr`
201			`;;; } 5 List`
202			`;;; } 4 DeclItem`
203			`;;; { 4 DeclItem`
204			`;;; what = DECL_NAME`
205			`;;; name = t`
206			`;;; } 4 DeclItem`
207			`;;; } 3 List`
208			`;;; { 3 Initializer (skalar)`
209			`;;; { 4 Expression (variable name)`
210			`;;; expr_type = "identifier" (current_task)`
211	2	jsauermann	`;-- load_rr_var current_task, (16 bit)`
212			`MOVE (Ccurrent_task), RR`
213	7	jsauermann	`;;; } 4 Expression (variable name)`
214	2	jsauermann	`;-- push_rr (16 bit)`
215			`MOVE RR, -(SP)`
216	7	jsauermann	`;;; } 3 Initializer (skalar)`
217			`;;; } 2 InitDeclarator`
218	2	jsauermann	`;;; { 2 List`
219			`;;; { 3 ExpressionStatement`
220
221			`st_loop:`
222			`MOVE 0(SP), RR ; RR = t`
223			`MOVE (RR), RR ; RR = t->next_task`
224			`MOVE RR, 0(SP) ; t = t->next_task`
225			`ADD RR, #4 ; RR = & t->status`
226			`MOVE (RR), RS ; RR = t->status`
227			`JMP RRNZ, st_next_task ; jump if (status != 0)`
228			`;`
229			`MOVE 2(SP), RR ; RR = next`
230			`JMP RRZ, st_accept ; jump if (next == 0)`
231			`;`
232			`ADD RR, #5 ; RR = & next->priority`
233			`MOVE (RR), RS ; RR = next->priority`
234			`MOVE RR, LL ; LL = next->priority`
235			`MOVE 0(SP), RR ; RR = t`
236			`ADD RR, #5 ; RR = & t->priority`
237			`MOVE (RR), RS ; RR = t->priority`
238			`SGT LL, RR ; RR = (next->priority > t->priority)`
239			`JMP RRNZ, st_next_task ; jump if (next->priority > t->priority)`
240			`st_accept: ;`
241			`MOVE 0(SP), RR ; RR = t`
242			`MOVE RR, 2(SP) ; next = t`
243			`st_next_task: ;`
244			`MOVE 0(SP), RR ; RR = t`
245			`MOVE (Ccurrent_task), LL ; LL = current_task`
246			`SNE LL, RR ; RR = (t != current_task)`
247			`JMP RRNZ, st_loop ;`
248
249			`;;; } 3 ExpressionStatement`
250			`;;; { 3 IfElseStatement`
251			`;;; { 4 Expr l != r`
252			`;;; { 5 TypeName`
253			`;;; { 6 TypeSpecifier (struct/union)`
254			`;;; spec = struct '_task' (800000)`
255			`;;; name = _task`
256			`;;; } 6 TypeSpecifier (struct/union)`
257			`;;; { 6 List`
258			`;;; { 7 DeclItem`
259			`;;; what = DECL_POINTER`
260			`;;; { 8 List`
261			`;;; { 9 Ptr`
262			`;;; } 9 Ptr`
263			`;;; } 8 List`
264			`;;; } 7 DeclItem`
265			`;;; { 7 DeclItem`
266			`;;; what = DECL_NAME`
267			`;;; name = current_task`
268			`;;; } 7 DeclItem`
269			`;;; } 6 List`
270			`;;; } 5 TypeName`
271			`;;; { 5 Expression (variable name)`
272			`;;; expr_type = "identifier" (current_task)`
273			`;-- load_rr_var current_task, (16 bit)`
274			`MOVE (Ccurrent_task), RR`
275			`;;; } 5 Expression (variable name)`
276			`;-- move_rr_to_ll`
277			`MOVE RR, LL`
278			`;;; { 5 Expression (variable name)`
279			`;;; expr_type = "identifier" (next)`
280			`;-- load_rr_var next = -2(FP), SP at -4 (16 bit)`
281			`MOVE 2(SP), RR`
282			`;;; } 5 Expression (variable name)`
283			`;-- l != r`
284			`SNE LL, RR`
285			`;;; } 4 Expr l != r`
286			`;-- branch_false`
287			`JMP RRZ, L2_endif_1`
288			`;;; { 4 CompoundStatement`
289			`;;; { 5 List`
290			`;;; { 6 ExpressionStatement`
291			`;;; { 7 Expr l = r`
292			`;;; { 8 TypeName`
293			`;;; { 9 TypeSpecifier (all)`
294			`;;; spec = int (80000)`
295			`;;; } 9 TypeSpecifier (all)`
296			`;;; { 9 List`
297			`;;; { 10 DeclItem`
298			`;;; what = DECL_POINTER`
299			`;;; { 11 List`
300			`;;; { 12 Ptr`
301			`;;; } 12 Ptr`
302			`;;; } 11 List`
303			`;;; } 10 DeclItem`
304			`;;; { 10 DeclItem`
305			`;;; what = DECL_NAME`
306			`;;; name = stack_pointer`
307			`;;; } 10 DeclItem`
308			`;;; } 9 List`
309			`;;; } 8 TypeName`
310			`;;; { 8 Expression (cast)r`
311			`LEA 0(SP), RR`
312			`;;; } 8 Expression (cast)r`
313			`;-- push_rr (16 bit)`
314			`MOVE RR, -(SP)`
315			`;;; { 8 Expr * r`
316			`;;; { 9 Expression (variable name)`
317			`;;; expr_type = "identifier" (current_task)`
318			`;-- load_rr_var current_task, (16 bit)`
319			`MOVE (Ccurrent_task), RR`
320			`;;; } 9 Expression (variable name)`
321			`;;; } 8 Expr * r`
322			`;-- + (member)`
323			`ADD RR, #0x0002`
324			`;-- move_rr_to_ll`
325			`MOVE RR, LL`
326			`;-- pop_rr (16 bit)`
327			`MOVE (SP)+, RR`
328			`;-- assign (16 bit)`
329			`MOVE RR, (LL)`
330			`;;; } 7 Expr l = r`
331			`;;; } 6 ExpressionStatement`
332			`;;; { 6 ExpressionStatement`
333			`;;; { 7 Expr l = r`
334			`;;; { 8 TypeName`
335			`;;; { 9 TypeSpecifier (struct/union)`
336			`;;; spec = struct '_task' (800000)`
337			`;;; name = _task`
338			`;;; } 9 TypeSpecifier (struct/union)`
339			`;;; { 9 List`
340			`;;; { 10 DeclItem`
341			`;;; what = DECL_POINTER`
342			`;;; { 11 List`
343			`;;; { 12 Ptr`
344			`;;; } 12 Ptr`
345			`;;; } 11 List`
346			`;;; } 10 DeclItem`
347			`;;; { 10 DeclItem`
348			`;;; what = DECL_NAME`
349			`;;; name = current_task`
350			`;;; } 10 DeclItem`
351			`;;; } 9 List`
352			`;;; } 8 TypeName`
353			`;;; { 8 Expression (variable name)`
354			`;;; expr_type = "identifier" (next)`
355			`;-- load_rr_var next = -2(FP), SP at -4 (16 bit)`
356			`MOVE 2(SP), RR`
357			`;;; } 8 Expression (variable name)`
358			`;-- store_rr_var current_task`
359			`MOVE RR, (Ccurrent_task)`
360			`;;; } 7 Expr l = r`
361			`;;; } 6 ExpressionStatement`
362			`;;; { 6 ExpressionStatement`
363			`;;; { 7 Expr * r`
364			`;;; { 8 Expression (variable name)`
365			`;;; expr_type = "identifier" (current_task)`
366			`;-- load_rr_var current_task, (16 bit)`
367			`MOVE (Ccurrent_task), RR`
368			`;;; } 8 Expression (variable name)`
369			`;;; } 7 Expr * r`
370			`;-- + (member)`
371			`ADD RR, #0x0002`
372			`;-- content`
373			`MOVE (RR), RR`
374			`;;; } 6 ExpressionStatement`
375			`;;; { 6 ExpressionStatement`
376			`MOVE RR, SP`
377			`;;; } 6 ExpressionStatement`
378			`;;; } 5 List`
379	7	jsauermann	`;-- pop 0 bytes`
380	2	jsauermann	`;;; } 4 CompoundStatement`
381			`L2_endif_1:`
382			`;;; } 3 IfElseStatement`
383			`;;; } 2 List`
384	7	jsauermann	`;-- pop 4 bytes`
385			`ADD SP, #4`
386	2	jsauermann	`;;; } 1 CompoundStatement`
387			`;-- ret`
388			`RET`
389			`;;; ------------------------------------;`
390	7	jsauermann	`;;; { 1 FunctionDefinition`
391			`;;; { 2 TypeName`
392			`;;; { 3 TypeSpecifier (all)`
393			`;;; spec = void (10000)`
394			`;;; } 3 TypeSpecifier (all)`
395			`;;; { 3 List`
396			`;;; { 4 DeclItem`
397			`;;; what = DECL_NAME`
398			`;;; name = P`
399			`;;; } 4 DeclItem`
400			`;;; } 3 List`
401			`;;; } 2 TypeName`
402	2	jsauermann	`;;; { 2 List`
403			`;;; { 3 DeclItem`
404			`;;; what = DECL_NAME`
405			`;;; name = P`
406			`;;; } 3 DeclItem`
407	7	jsauermann	`;;; { 3 DeclItem`
408			`;;; what = DECL_FUN`
409			`;;; { 4 List`
410			`;;; { 5 ParameterDeclaration`
411			`;;; isEllipsis = false`
412			`;;; { 6 TypeName`
413			`;;; { 7 TypeSpecifier (struct/union)`
414			`;;; spec = struct '_semaphore' (800000)`
415			`;;; name = _semaphore`
416			`;;; } 7 TypeSpecifier (struct/union)`
417			`;;; { 7 List`
418			`;;; { 8 DeclItem`
419			`;;; what = DECL_POINTER`
420			`;;; { 9 List`
421			`;;; { 10 Ptr`
422			`;;; } 10 Ptr`
423			`;;; } 9 List`
424			`;;; } 8 DeclItem`
425			`;;; { 8 DeclItem`
426			`;;; what = DECL_NAME`
427			`;;; name = sema`
428			`;;; } 8 DeclItem`
429			`;;; } 7 List`
430			`;;; } 6 TypeName`
431			`;;; } 5 ParameterDeclaration`
432			`;;; } 4 List`
433			`;;; } 3 DeclItem`
434	2	jsauermann	`;;; } 2 List`
435			`CP:`
436	7	jsauermann	`;;; { 2 CompoundStatement`
437			`;;; { 3 List`
438			`;;; { 4 ExpressionStatement`
439	2	jsauermann	`DI`
440	7	jsauermann	`;;; } 4 ExpressionStatement`
441			`;;; { 4 IfElseStatement`
442			`;;; { 5 Expr l < r`
443			`;;; { 6 TypeName (internal)`
444			`;;; { 7 TypeSpecifier (all)`
445			`;;; spec = int (80000)`
446			`;;; } 7 TypeSpecifier (all)`
447			`;;; } 6 TypeName (internal)`
448			`;;; { 6 Expr --r`
449			`;;; { 7 Expr * r`
450			`;;; { 8 Expression (variable name)`
451			`;;; expr_type = "identifier" (sema)`
452	2	jsauermann	`;-- load_rr_var sema = 2(FP), SP at 0 (16 bit)`
453			`MOVE 2(SP), RR`
454	7	jsauermann	`;;; } 8 Expression (variable name)`
455			`;;; } 7 Expr * r`
456	2	jsauermann	`;-- + (member)`
457			`;-- move_rr_to_ll`
458			`MOVE RR, LL`
459			`;-- content`
460			`MOVE (RR), RR`
461			`;-- --`
462			`SUB RR, #0x0001`
463			`;-- assign (16 bit)`
464			`MOVE RR, (LL)`
465	7	jsauermann	`;;; } 6 Expr --r`
466	2	jsauermann	`;-- l < r`
467			`SLT RR, #0x0000`
468	7	jsauermann	`;;; } 5 Expr l < r`
469	2	jsauermann	`;-- branch_false`
470			`JMP RRZ, L3_endif_2`
471	7	jsauermann	`;;; { 5 CompoundStatement`
472			`;;; { 6 List`
473			`;;; { 7 ExpressionStatement`
474			`;;; { 8 Expr l = r`
475			`;;; { 9 TypeName`
476			`;;; { 10 TypeSpecifier (struct/union)`
477			`;;; spec = struct '_semaphore' (800000)`
478			`;;; name = _semaphore`
479			`;;; } 10 TypeSpecifier (struct/union)`
480			`;;; { 10 List`
481			`;;; { 11 DeclItem`
482			`;;; what = DECL_POINTER`
483			`;;; { 12 List`
484			`;;; { 13 Ptr`
485			`;;; } 13 Ptr`
486			`;;; } 12 List`
487			`;;; } 11 DeclItem`
488			`;;; { 11 DeclItem`
489			`;;; what = DECL_NAME`
490			`;;; name = waiting_for`
491			`;;; } 11 DeclItem`
492			`;;; } 10 List`
493			`;;; } 9 TypeName`
494			`;;; { 9 Expression (variable name)`
495			`;;; expr_type = "identifier" (sema)`
496	2	jsauermann	`;-- load_rr_var sema = 2(FP), SP at 0 (16 bit)`
497			`MOVE 2(SP), RR`
498	7	jsauermann	`;;; } 9 Expression (variable name)`
499	2	jsauermann	`;-- push_rr (16 bit)`
500			`MOVE RR, -(SP)`
Browse

Tools

Subversion Repositories c16

[/] [c16/] [trunk/] [rtos.asm] - Blame information for rev 33
