//////////////////////////////////////////////////////////////////////////////
//                                                                           /
// IAR ARM ANSI C/C++ Compiler V4.11A/W32              20/Jul/2004  18:58:50 /
// Copyright 1999-2004 IAR Systems. All rights reserved.                     /
//                                                                           /
//    Cpu mode        =  arm                                                 /
//    Endian          =  little                                              /
//    Stack alignment =  4                                                   /
//    Source file     =  C:\medusa\zl_mirror.c                               /
//    Command line    =  -I "C:\Program Files\IAR Systems\Embedded           /
//                       Workbench 4.0\ARM\INC\" -lc C:\medusa\Debug\List\   /
//                       -la C:\medusa\Debug\List\ -o C:\medusa\Debug\Obj\   /
//                       -s2 --no_cse --no_unroll --no_inline                /
//                       --no_code_motion --no_tbaa --no_clustering          /
//                       --no_scheduling --debug --cpu_mode arm --endian     /
//                       little --cpu ARM7TDMI-S --stack_align 4 -e --fpu    /
//                       None "-D_DLIB_CONFIG_FILE=C:\Program Files\IAR      /
//                       Systems\Embedded Workbench                          /
//                       4.0\ARM\LIB\dl4tpannl8n.h" C:\medusa\zl_mirror.c    /
//    List file       =  C:\medusa\Debug\List\zl_mirror.s79                  /
//                                                                           /
//                                                                           /
//////////////////////////////////////////////////////////////////////////////

        NAME zl_mirror

        RTMODEL "ARMv4M", "USED"
        RTMODEL "StackAlign4", "USED"
        RTMODEL "__cpu_mode", "__pcs__arm"
        RTMODEL "__data_model", "absolute"
        RTMODEL "__dlib_file_descriptor", "0"
        RTMODEL "__endian", "little"
        RTMODEL "__rt_version", "6"

        RSEG CSTACK:DATA:NOROOT(2)

??DataTable0 EQU 0
??DataTable1 EQU 0
??DataTable10 EQU 0
??DataTable11 EQU 0
??DataTable12 EQU 0
??DataTable13 EQU 0
??DataTable14 EQU 0
??DataTable15 EQU 0
??DataTable16 EQU 0
??DataTable17 EQU 0
??DataTable2 EQU 0
??DataTable3 EQU 0
??DataTable4 EQU 0
??DataTable5 EQU 0
??DataTable6 EQU 0
??DataTable7 EQU 0
??DataTable8 EQU 0
??DataTable9 EQU 0
        PUBWEAK ?init?tab?DATA_Z
        FUNCTION addMirror,0203H
        LOCFRAME CSTACK, 24, STACK
        MULTWEAK cliRegisterCommand??rA
        MULTWEAK clicharGetOutputBuffer??rA
        MULTWEAK clicharSendOutputBuffer??rA
        FUNCTION mirrorHandler,0603H
        LOCFRAME CSTACK, 40, STACK
        FUNCTION printAllMirrors,0203H
        LOCFRAME CSTACK, 24, STACK
        FUNCTION removeMirror,0203H
        LOCFRAME CSTACK, 16, STACK
        MULTWEAK sprintf??rA
        MULTWEAK strtol??rA
        MULTWEAK zarlinkIndexedWrite??rA
        PUBLIC zarlinkMirrorInit
        FUNCTION zarlinkMirrorInit,0203H
        LOCFRAME CSTACK, 4, STACK
        
        CFI Names cfiNames0
        CFI StackFrame CFA R13 HUGEDATA
        CFI Resource R0:32, R1:32, R2:32, R3:32, R4:32, R5:32, R6:32, R7:32
        CFI Resource R8:32, R9:32, R10:32, R11:32, R12:32, CPSR:32, R13:32
        CFI Resource R14:32, SPSR:32
        CFI VirtualResource ?RET:32
        CFI EndNames cfiNames0
        
        CFI Common cfiCommon0 Using cfiNames0
        CFI CodeAlign 4
        CFI DataAlign 4
        CFI ReturnAddress ?RET CODE
        CFI CFA R13+0
        CFI R0 Undefined
        CFI R1 Undefined
        CFI R2 Undefined
        CFI R3 Undefined
        CFI R4 SameValue
        CFI R5 SameValue
        CFI R6 SameValue
        CFI R7 SameValue
        CFI R8 SameValue
        CFI R9 SameValue
        CFI R10 SameValue
        CFI R11 SameValue
        CFI R12 Undefined
        CFI CPSR SameValue
        CFI R14 Undefined
        CFI SPSR SameValue
        CFI ?RET R14
        CFI EndCommon cfiCommon0
        
cliRegisterCommand  SYMBOL "cliRegisterCommand"
clicharGetOutputBuffer SYMBOL "clicharGetOutputBuffer"
clicharSendOutputBuffer SYMBOL "clicharSendOutputBuffer"
sprintf             SYMBOL "sprintf"
strtol              SYMBOL "strtol"
zarlinkIndexedWrite SYMBOL "zarlinkIndexedWrite"
cliRegisterCommand??rA SYMBOL "??rA", cliRegisterCommand
clicharGetOutputBuffer??rA SYMBOL "??rA", clicharGetOutputBuffer
clicharSendOutputBuffer??rA SYMBOL "??rA", clicharSendOutputBuffer
sprintf??rA         SYMBOL "??rA", sprintf
strtol??rA          SYMBOL "??rA", strtol
zarlinkIndexedWrite??rA SYMBOL "??rA", zarlinkIndexedWrite

        EXTERN cliRegisterCommand
        FUNCTION cliRegisterCommand,0202H
        EXTERN clicharGetOutputBuffer
        FUNCTION clicharGetOutputBuffer,0202H
        EXTERN clicharSendOutputBuffer
        FUNCTION clicharSendOutputBuffer,0202H
        EXTERN sprintf
        FUNCTION sprintf,010202H
        EXTERN strtol
        FUNCTION strtol,010202H
        EXTERN zarlinkIndexedWrite
        FUNCTION zarlinkIndexedWrite,0202H


        RSEG DATA_Z:DATA:SORT:NOROOT(2)
mirrors:
        DS8 32

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock0 Using cfiCommon0
        CFI Function addMirror
   CODE32      
addMirror:
   STMDB       SP!,{R4-R8,LR}     ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R8 Frame(CFA, -8)
        CFI R7 Frame(CFA, -12)
        CFI R6 Frame(CFA, -16)
        CFI R5 Frame(CFA, -20)
        CFI R4 Frame(CFA, -24)
        CFI CFA R13+24
   MOV         R4,R0
   MOV         R5,R1
   MOV         R6,R2
   CMP         R5,#+0x1
   BEQ         ??addMirror_0
   CMP         R5,#+0x2
   BEQ         ??addMirror_0
   MVN         R0,#+0x0
   B           ??addMirror_1
??addMirror_0:
   MOV         R0,#+0x0
   MOV         R7,R0
??addMirror_2:
   CMP         R7,#+0x2
   BGE         ??addMirror_3
   MOV         R1,#+0x10
   LDR         R2,??DataTable18   ;; mirrors
   MLAS        R3,R1,R7,R2
   LDR         R12,[R3, #+8]
   CMP         R12,#+0x0
   BEQ         ??addMirror_3
   ADDS        R7,R7,#+0x1
   B           ??addMirror_2
??addMirror_3:
   CMP         R7,#+0x2
   BNE         ??addMirror_4
   MVN         R0,#+0x0
   B           ??addMirror_1
??addMirror_4:
   MOV         LR,#+0x80
   MOV         R8,LR
   ANDS        R0,R4,#+0x7
   ORRS        R8,R8,R0
   MOV         R1,R6
   ANDS        R2,R1,#+0x7
   ORRS        R8,R8,R2, LSL #+4
   CMP         R5,#+0x1
   BNE         ??addMirror_5
   ANDS        R8,R8,#+0xF7
   B           ??addMirror_6
??addMirror_5:
   CMP         R5,#+0x2
   BNE         ??addMirror_6
   ORRS        R8,R8,#+0x8
??addMirror_6:
   MOV         R3,#+0x10
   LDR         R12,??DataTable18  ;; mirrors
   MLAS        LR,R3,R7,R12
   STR         R4,[LR, #+0]
   MOV         R0,#+0x10
   LDR         R1,??DataTable18   ;; mirrors
   MLAS        R2,R0,R7,R1
   STR         R5,[R2, #+8]
   MOV         R3,#+0x10
   LDR         R12,??DataTable18  ;; mirrors
   MLAS        LR,R3,R7,R12
   STR         R6,[LR, #+12]
   MOV         R1,R8
   ANDS        R1,R1,#+0xFF       ;; Zero extend
   MOV         R0,#+0x10
   LDR         R2,??DataTable18   ;; mirrors
   MLAS        R3,R0,R7,R2
   LDR         R0,[R3, #+4]
   MOV         R0,R0, LSL #+16
   MOVS        R0,R0, LSR #+16
   _BLF        zarlinkIndexedWrite,zarlinkIndexedWrite??rA
   MOV         R0,#+0x0
??addMirror_1:
   LDMIA       SP!,{R4-R8,PC}     ;; return
        CFI EndBlock cfiBlock0

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock1 Using cfiCommon0
        CFI Function removeMirror
   CODE32      
removeMirror:
   STMDB       SP!,{R4-R6,LR}     ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R6 Frame(CFA, -8)
        CFI R5 Frame(CFA, -12)
        CFI R4 Frame(CFA, -16)
        CFI CFA R13+16
   MOV         R4,R0
   MOV         R5,R1
   CMP         R5,#+0x1
   BEQ         ??removeMirror_0
   CMP         R5,#+0x2
   BEQ         ??removeMirror_0
   MVN         R0,#+0x0
   B           ??removeMirror_1
??removeMirror_0:
   MOV         R0,#+0x0
   MOV         R6,R0
??removeMirror_2:
   CMP         R6,#+0x2
   BGE         ??removeMirror_3
   MOV         R1,#+0x10
   LDR         R2,??DataTable18   ;; mirrors
   MLAS        R3,R1,R6,R2
   LDR         R12,[R3, #+0]
   CMP         R12,R4
   BNE         ??removeMirror_4
   MOV         LR,#+0x10
   LDR         R0,??DataTable18   ;; mirrors
   MLAS        R1,LR,R6,R0
   LDR         R2,[R1, #+8]
   CMP         R2,R5
   BNE         ??removeMirror_4
   MOV         R3,#+0x10
   LDR         R12,??DataTable18  ;; mirrors
   MLAS        LR,R3,R6,R12
   MOV         R0,#+0x0
   STR         R0,[LR, #+8]
   B           ??removeMirror_3
??removeMirror_4:
   ADDS        R6,R6,#+0x1
   B           ??removeMirror_2
??removeMirror_3:
   CMP         R6,#+0x2
   BNE         ??removeMirror_5
   MVN         R0,#+0x0
   B           ??removeMirror_1
??removeMirror_5:
   MOV         R1,#+0x0
   MOV         R2,#+0x10
   LDR         R3,??DataTable18   ;; mirrors
   MLAS        R12,R2,R6,R3
   LDR         R0,[R12, #+4]
   MOV         R0,R0, LSL #+16
   MOVS        R0,R0, LSR #+16
   _BLF        zarlinkIndexedWrite,zarlinkIndexedWrite??rA
   MOV         R0,#+0x0
??removeMirror_1:
   LDMIA       SP!,{R4-R6,PC}     ;; return
        CFI EndBlock cfiBlock1

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock2 Using cfiCommon0
        CFI Function printAllMirrors
   CODE32      
printAllMirrors:
   STMDB       SP!,{R4,R5,LR}     ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R5 Frame(CFA, -8)
        CFI R4 Frame(CFA, -12)
        CFI CFA R13+12
   SUB         SP,SP,#+0x4
        CFI CFA R13+16
   MOV         R0,SP
   _BLF        clicharGetOutputBuffer,clicharGetOutputBuffer??rA
   MOV         R4,R0
   MOV         R0,#+0x0
   MOV         R5,R0
??printAllMirrors_0:
   CMP         R5,#+0x2
   BGE         ??printAllMirrors_1
   MOV         R1,#+0x10
   LDR         R2,??DataTable18   ;; mirrors
   MLAS        R3,R1,R5,R2
   LDR         R12,[R3, #+8]
   CMP         R12,#+0x0
   BEQ         ??printAllMirrors_2
   MOV         LR,#+0x10
   LDR         R0,??DataTable18   ;; mirrors
   MLAS        R1,LR,R5,R0
   LDR         R2,[R1, #+8]
   CMP         R2,#+0x1
   BNE         ??printAllMirrors_3
   LDR         R0,??printAllMirrors_4  ;; `?<Constant "ingress">`
   B           ??printAllMirrors_5
??printAllMirrors_3:
   LDR         R0,??printAllMirrors_4+4  ;; `?<Constant "egress">`
??printAllMirrors_5:
   MOV         R3,#+0x10
   LDR         R12,??DataTable18  ;; mirrors
   MLAS        LR,R3,R5,R12
   LDR         R1,[LR, #+12]
   STMDB       SP!,{R0,R1}        ;; Push
        CFI CFA R13+24
   MOV         R0,#+0x10
   LDR         R1,??DataTable18   ;; mirrors
   MLAS        R2,R0,R5,R1
   LDR         R3,[R2, #+0]
   MOV         R2,R5
   LDR         R1,??printAllMirrors_4+8  ;; `?<Constant "mirror[%d] port[%d] %...">`
   MOV         R0,R4
   _BLF        sprintf,sprintf??rA
   ADD         SP,SP,#+0x8        ;; stack cleaning
        CFI CFA R13+16
   B           ??printAllMirrors_6
??printAllMirrors_2:
   MOV         R2,R5
   LDR         R1,??printAllMirrors_4+12  ;; `?<Constant "mirror[%d] not enabled\\r\\n">`
   MOV         R0,R4
   _BLF        sprintf,sprintf??rA
??printAllMirrors_6:
   LDR         R1,[SP, #+0]
   MOV         R0,R4
   _BLF        clicharSendOutputBuffer,clicharSendOutputBuffer??rA
   ADDS        R5,R5,#+0x1
   B           ??printAllMirrors_0
??printAllMirrors_1:
   ADD         SP,SP,#+0x4        ;; stack cleaning
        CFI CFA R13+12
   LDMIA       SP!,{R4,R5,PC}     ;; return
   DATA        
??printAllMirrors_4:
   DC32        `?<Constant "ingress">`
   DC32        `?<Constant "egress">`
   DC32        `?<Constant "mirror[%d] port[%d] %...">`
   DC32        `?<Constant "mirror[%d] not enabled\\r\\n">`
        CFI EndBlock cfiBlock2

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock3 Using cfiCommon0
        CFI Function mirrorHandler
   CODE32      
mirrorHandler:
   STMDB       SP!,{R4-R10,LR}    ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R10 Frame(CFA, -8)
        CFI R9 Frame(CFA, -12)
        CFI R8 Frame(CFA, -16)
        CFI R7 Frame(CFA, -20)
        CFI R6 Frame(CFA, -24)
        CFI R5 Frame(CFA, -28)
        CFI R4 Frame(CFA, -32)
        CFI CFA R13+32
   SUB         SP,SP,#+0x8
        CFI CFA R13+40
   MOV         R7,R0
   MOV         R8,R1
   MOV         R9,R2
   MVN         R0,#+0x0
   MOV         R10,R0
   CMP         R7,#+0x1
   BNE         ??mirrorHandler_0
   MOV         R1,#+0x0
   MOV         R10,R1
   BL          printAllMirrors
   B           ??mirrorHandler_1
??mirrorHandler_0:
   CMP         R7,#+0x4
   BNE         ??mirrorHandler_2
   MOV         R2,#+0xA
   MOV         R1,#+0x0
   LDR         R0,[R8, #+4]
   _BLF        strtol,strtol??rA
   MOV         R4,R0
   LDR         R2,[R8, #+8]
   LDRB        R3,[R2, #+0]
   ANDS        R3,R3,#+0xFF       ;; Zero extend
   CMP         R3,#+0x45
   BEQ         ??mirrorHandler_3
   CMP         R3,#+0x49
   BEQ         ??mirrorHandler_4
   CMP         R3,#+0x65
   BEQ         ??mirrorHandler_3
   CMP         R3,#+0x69
   BNE         ??mirrorHandler_5
??mirrorHandler_4:
   MOV         LR,#+0x1
   MOV         R6,LR
   B           ??mirrorHandler_6
??mirrorHandler_3:
   MOV         R0,#+0x2
   MOV         R6,R0
   B           ??mirrorHandler_6
??mirrorHandler_5:
   MVN         R0,#+0x0
   B           ??mirrorHandler_7
??mirrorHandler_6:
   LDR         R1,[R8, #+12]
   LDRB        R2,[R1, #+0]
   CMP         R2,#+0x64
   BEQ         ??mirrorHandler_8
   LDR         R3,[R8, #+12]
   LDRB        R12,[R3, #+0]
   CMP         R12,#+0x44
   BNE         ??mirrorHandler_9
??mirrorHandler_8:
   MOV         R1,R6
   MOV         R0,R4
   BL          removeMirror
   MOV         R10,R0
   BL          printAllMirrors
   B           ??mirrorHandler_1
??mirrorHandler_9:
   MOV         R2,#+0xA
   MOV         R1,#+0x0
   LDR         R0,[R8, #+12]
   _BLF        strtol,strtol??rA
   MOV         R5,R0
   MOV         R2,R5
   MOV         R1,R6
   MOV         R0,R4
   BL          addMirror
   MOV         R10,R0
   BL          printAllMirrors
   B           ??mirrorHandler_1
??mirrorHandler_2:
   MVN         LR,#+0x0
   MOV         R10,LR
??mirrorHandler_1:
   MOV         R0,R10
??mirrorHandler_7:
   ADD         SP,SP,#+0x8        ;; stack cleaning
        CFI CFA R13+32
   LDMIA       SP!,{R4-R10,PC}    ;; return
        CFI EndBlock cfiBlock3

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock4 Using cfiCommon0
        CFI Function zarlinkMirrorInit
   CODE32      
zarlinkMirrorInit:
   STMDB       SP!,{LR}           ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI CFA R13+4
   LDR         R0,??DataTable18   ;; mirrors
   MOV         R1,#+0x710
   STR         R1,[R0, #+4]
   LDR         R2,??DataTable18   ;; mirrors
   MOV         R3,#+0x0
   STR         R3,[R2, #+8]
   LDR         R12,??DataTable18  ;; mirrors
   MOV         R0,#+0x11
   ORR         R0,R0,#+0x700
   STR         R0,[R12, #+20]
   LDR         R1,??DataTable18   ;; mirrors
   MOV         R2,#+0x0
   STR         R2,[R1, #+24]
   MOV         R1,#+0x0
   LDR         R3,??DataTable18   ;; mirrors
   LDR         R0,[R3, #+4]
   MOV         R0,R0, LSL #+16
   MOVS        R0,R0, LSR #+16
   _BLF        zarlinkIndexedWrite,zarlinkIndexedWrite??rA
   MOV         R1,#+0x0
   LDR         R12,??DataTable18  ;; mirrors
   LDR         R0,[R12, #+20]
   MOV         R0,R0, LSL #+16
   MOVS        R0,R0, LSR #+16
   _BLF        zarlinkIndexedWrite,zarlinkIndexedWrite??rA
   LDR         R2,??zarlinkMirrorInit_0  ;; `?<Constant "mirror [port] [ingres...">`
   LDR         R1,??zarlinkMirrorInit_0+4  ;; mirrorHandler
   LDR         R0,??zarlinkMirrorInit_0+8  ;; `?<Constant "mirror">`
   _BLF        cliRegisterCommand,cliRegisterCommand??rA
   MOV         R0,#+0x0
   LDMIA       SP!,{PC}           ;; return
   DATA        
??zarlinkMirrorInit_0:
   DC32        `?<Constant "mirror [port] [ingres...">`
   DC32        mirrorHandler
   DC32        `?<Constant "mirror">`
        CFI EndBlock cfiBlock4

        RSEG CODE:CODE:NOROOT(2)
   DATA        
??DataTable18:
   DC32        mirrors

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock5 Using cfiCommon0
        CFI NoFunction
   CODE32      
zarlinkIndexedWrite??rA:
   LDR         R12,??Subroutine0_0  ;; zarlinkIndexedWrite
   MOV         PC,R12
   DATA        
??Subroutine0_0:
   DC32        zarlinkIndexedWrite
        CFI EndBlock cfiBlock5

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock6 Using cfiCommon0
        CFI NoFunction
   CODE32      
clicharGetOutputBuffer??rA:
   LDR         R12,??Subroutine1_0  ;; clicharGetOutputBuffer
   MOV         PC,R12
   DATA        
??Subroutine1_0:
   DC32        clicharGetOutputBuffer
        CFI EndBlock cfiBlock6

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock7 Using cfiCommon0
        CFI NoFunction
   CODE32      
sprintf??rA:
   LDR         R12,??Subroutine2_0  ;; sprintf
   MOV         PC,R12
   DATA        
??Subroutine2_0:
   DC32        sprintf
        CFI EndBlock cfiBlock7

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock8 Using cfiCommon0
        CFI NoFunction
   CODE32      
clicharSendOutputBuffer??rA:
   LDR         R12,??Subroutine3_0  ;; clicharSendOutputBuffer
   MOV         PC,R12
   DATA        
??Subroutine3_0:
   DC32        clicharSendOutputBuffer
        CFI EndBlock cfiBlock8

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock9 Using cfiCommon0
        CFI NoFunction
   CODE32      
strtol??rA:
   LDR         R12,??Subroutine4_0  ;; strtol
   MOV         PC,R12
   DATA        
??Subroutine4_0:
   DC32        strtol
        CFI EndBlock cfiBlock9

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock10 Using cfiCommon0
        CFI NoFunction
   CODE32      
cliRegisterCommand??rA:
   LDR         R12,??Subroutine5_0  ;; cliRegisterCommand
   MOV         PC,R12
   DATA        
??Subroutine5_0:
   DC32        cliRegisterCommand
        CFI EndBlock cfiBlock10

        RSEG INITTAB:CODE:ROOT(2)
   DATA
?init?tab?DATA_Z:
   DCD      sfe(DATA_Z) - sfb(DATA_Z), sfb(DATA_Z), sfb(DATA_Z)

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "mirror[%d] port[%d] %...">`:
        DC8 "mirror[%d] port[%d] %s reflected to port[%d]\015\012"
        DC8 0

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "egress">`:
        DC8 "egress"
        DC8 0

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "ingress">`:
        DC8 "ingress"

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "mirror[%d] not enabled\\r\\n">`:
        DC8 "mirror[%d] not enabled\015\012"
        DC8 0, 0, 0

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "mirror">`:
        DC8 "mirror"
        DC8 0

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "mirror [port] [ingres...">`:
        DC8 6DH, 69H, 72H, 72H, 6FH, 72H, 20H, 5BH
        DC8 70H, 6FH, 72H, 74H, 5DH, 20H, 5BH, 69H
        DC8 6EH, 67H, 72H, 65H, 73H, 73H, 20H, 7CH
        DC8 20H, 65H, 67H, 72H, 65H, 73H, 73H, 5DH
        DC8 20H, 5BH, 72H, 65H, 66H, 6CH, 65H, 63H
        DC8 74H, 69H, 6FH, 6EH, 50H, 6FH, 72H, 74H
        DC8 20H, 7CH, 20H, 28H, 64H, 29H, 69H, 73H
        DC8 61H, 62H, 6CH, 65H, 5DH, 20H, 2DH, 20H
        DC8 72H, 65H, 70H, 6CH, 69H, 63H, 61H, 74H
        DC8 65H, 20H, 70H, 6FH, 72H, 74H, 20H, 74H
        DC8 72H, 61H, 66H, 66H, 69H, 63H, 0
        DC8 0

        END
// 
// 1 152 bytes in segment CODE
//   188 bytes in segment DATA_C
//    32 bytes in segment DATA_Z
//    12 bytes in segment INITTAB
// 
// 1 080 bytes of CODE  memory (+ 84 bytes shared)
//   188 bytes of CONST memory
//    32 bytes of DATA  memory
//
//Errors: none
//Warnings: 3
