
|===========================================================================|
Objects : -
debug_zog
    |
    +----userdefs.spin
    |
    +----zog_1_5_lsmod.spin
    |
    +----FullDuplexSerialPlus
    |
    +----fsrwFemto_rr001
    |           |
    |           +-------sdspiFemto
    |
    +----vmcog_v0_975.spin

Object Address : 0010 : Object Name : debug_zog
Object Address : 0850 : Object Name : userdefs.spin
Object Address : 085C : Object Name : zog_1_5_lsmod.spin
Object Address : 0FF4 : Object Name : FullDuplexSerialPlus
Object Address : 13F8 : Object Name : fsrwFemto_rr001
Object Address : 1CA0 : Object Name : sdspiFemto
Object Address : 26AC : Object Name : vmcog_v0_975.spin

Binary Image Information :
PBASE : 0010
VBASE : 2E1C
DBASE : 3554
PCURR : 00A9
DCURR : 355C
|===========================================================================|
|===========================================================================|
Object debug_zog
Object Base is 0010
|===========================================================================|
Object Constants
|===========================================================================|
Constant zpu_memory_size = 00010000 (65536)
Constant SPIN_MUL_OP = 000000F4 (244)
Constant SPIN_DIV_OP = 000000F6 (246)
Constant SPIN_REM_OP = 000000F7 (247)
Constant io_cmd_out = 00000001 (1)
Constant io_cmd_in = 00000002 (2)
Constant io_cmd_break = 00000003 (3)
Constant io_cmd_syscall = 00000004 (4)
Constant SYS_exit = 00000001 (1)
Constant SYS_open = 00000002 (2)
Constant SYS_close = 00000003 (3)
Constant SYS_read = 00000004 (4)
Constant SYS_write = 00000005 (5)
Constant SYS_lseek = 00000006 (6)
Constant SYS_unlink = 00000007 (7)
Constant SYS_getpid = 00000008 (8)
Constant SYS_kill = 00000009 (9)
Constant SYS_fstat = 0000000A (10)
Constant SYS_argvlen = 0000000C (12)
Constant SYS_argv = 0000000D (13)
Constant SYS_chdir = 0000000E (14)
Constant SYS_stat = 0000000F (15)
Constant SYS_chmod = 00000010 (16)
Constant SYS_utime = 00000011 (17)
Constant SYS_time = 00000012 (18)
Constant SYS_cognew = 00001F40 (8000)
Constant SYS_coginit = 00001F41 (8001)
Constant SYS_cogstop = 00001F42 (8002)
Constant STDIN_FILENO = 00000000 (0)
Constant STDOUT_FILENO = 00000001 (1)
Constant STDERR_FILENO = 00000002 (2)
Constant UART_TX_PORT = 80000024 (2147483684)
Constant UART_RX_PORT = 80000028 (2147483688)
Constant _clkmode = 00000408 (1032)
Constant _xinfreq = 00640000 (6553600)
Constant baud = 0001C200 (115200)
Constant spiDO = 00000009 (9)
Constant spiClk = 0000001C (28)
Constant spiDI = 00000008 (8)
Constant spiCS = 0000000E (14)
|===========================================================================|
|===========================================================================|
VBASE Global Variables
|===========================================================================|
VBASE : 0000 LONG Size 0004 Variable par_zpu_memory_addr
VBASE : 0004 LONG Size 0004 Variable par_zpu_memory_sz
VBASE : 0008 LONG Size 0004 Variable par_initial_pc
VBASE : 000C LONG Size 0004 Variable par_initial_sp
VBASE : 0010 LONG Size 0004 Variable par_dispatch_tab_addr
VBASE : 0014 LONG Size 0004 Variable par_pasm_addr
VBASE : 0018 LONG Size 0004 Variable par_zog_mbox_addr
VBASE : 001C LONG Size 0004 Variable par_vm_mbox_addr
VBASE : 0020 LONG Size 0004 Variable zog_mbox_command
VBASE : 0024 LONG Size 0004 Variable zog_mbox_port
VBASE : 0028 LONG Size 0004 Variable zog_mbox_data
VBASE : 002C LONG Size 0004 Variable zog_mbox_pc
VBASE : 0030 LONG Size 0004 Variable zog_mbox_sp
VBASE : 0034 LONG Size 0004 Variable zog_mbox_tos
VBASE : 0038 LONG Size 0004 Variable zog_mbox_dm
VBASE : 003C LONG Size 0004 Variable zog_mbox_debug
VBASE : 0040 LONG Size 0010 Variable vm_mbox
VBASE : 0050 LONG Size 0004 Variable cog
VBASE : 0054 LONG Size 0008 Variable ioControl
VBASE : 005C LONG Size 0004 Variable framep
VBASE : 0060 LONG Size 0004 Variable step_count
VBASE : 0064 WORD Size 0002 Variable err
VBASE : 0066 BYTE Size 0200 Variable diskbuff
|===========================================================================|
Object DAT Blocks
|===========================================================================|
00A0(0000)             | DAT                     org 0
00A0(0000) 00          | zpu_memory              byte ' Force zpu_memory to be BYTE type.
00A0(0000) 66          | filename byte "fibo.bin",0
00A1(0000) 69          | 
00A2(0000) 62          | 
00A3(0000) 6F          | 
00A4(0001) 2E          | 
00A5(0001) 62          | 
00A6(0001) 69          | 
00A7(0001) 6E          | 
00A8(0002) 00          | 
|===========================================================================|
|===========================================================================|
Spin Block start with 0 Parameters and 1 Extra Stack Longs. Method 1
PUB start : okay | n

Local Parameter DBASE:0000 - okay
Local Variable  DBASE:0004 - n
|===========================================================================|
278                        ser.start(def#conRxPin, def#conTxPin, def#conMode, def#conBaud) 'Start the debug Terminal
Addr : 00A9:             01  : Drop Anchor   
Addr : 00AA:          37 24  : Constant Mask Y=36 Decrement 0000001F 31
Addr : 00AC:          38 1E  : Constant 1 Bytes - 1E - $0000001E 30
Addr : 00AE:             35  : Constant 1 $00000000
Addr : 00AF:    3A 01 C2 00  : Constant 3 Bytes - 01 C2 00 - $0001C200 115200
Addr : 00B3:       06 21 01  : Call Obj.Sub 33 1
279                        ser.str(string("ZOG v1.5"))
Addr : 00B6:             01  : Drop Anchor   
Addr : 00B7: PBASE Constant Address of Label0002
Addr : 00B7:       87 81 30  : Memory Op Byte PBASE + ADDRESS Address = 0130
Addr : 00BA:       06 21 0D  : Call Obj.Sub 33 13
287                        vm.start(@vm_mbox, $7C00, 10)                          'Start up VMCOG
Addr : 00BD:             01  : Drop Anchor   
Addr : 00BE:          CB 40  : Memory Op Long VBASE + ADDRESS Address = 0040
Addr : 00C0:       39 7C 00  : Constant 2 Bytes - 7C 00 - $00007C00 31744
Addr : 00C3:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 00C5:       06 23 01  : Call Obj.Sub 35 1
288                        ser.str(string(" (VM)"))
Addr : 00C8:             01  : Drop Anchor   
Addr : 00C9: PBASE Constant Address of Label0003
Addr : 00C9:       87 81 39  : Memory Op Byte PBASE + ADDRESS Address = 0139
Addr : 00CC:       06 21 0D  : Call Obj.Sub 33 13
296                        crlf
Addr : 00CF:             01  : Drop Anchor   
Addr : 00D0:          05 1D  : Call Sub 29   
297                        waitcnt(cnt+80_000_000)                               'Give serial terminal window time
Addr : 00D2:          3F 91  : Register op CNT Read
Addr : 00D4: 3B 04 C4 B4 00  : Constant 4 Bytes - 04 C4 B4 00 - $04C4B400 80000000
Addr : 00D9:             EC  : Math Op +     
Addr : 00DA:             23  : WaitCnt(count)
320                        ser.str (string("Starting SD driver...",))
Addr : 00DB:             01  : Drop Anchor   
Addr : 00DC: PBASE Constant Address of Label0004
Addr : 00DC:       87 81 3F  : Memory Op Byte PBASE + ADDRESS Address = 013F
Addr : 00DF:       06 21 0D  : Call Obj.Sub 33 13
321                        err := sd.startSD(@ioControl)                         'Start the SD routines
Addr : 00E2:             00  : Drop Anchor Push 
Addr : 00E3:          CB 54  : Memory Op Long VBASE + ADDRESS Address = 0054
Addr : 00E5:       06 22 01  : Call Obj.Sub 34 1
Addr : 00E8:          A9 64  : Memory Op Word VBASE + WRITE Address = 0064
322                        ser.hex(err, 8)
Addr : 00EA:             01  : Drop Anchor   
Addr : 00EB:          A8 64  : Memory Op Word VBASE + READ Address = 0064
Addr : 00ED:          37 02  : Constant Mask Y=2 00000008 8
Addr : 00EF:       06 21 15  : Call Obj.Sub 33 21
323                        crlf
Addr : 00F2:             01  : Drop Anchor   
Addr : 00F3:          05 1D  : Call Sub 29   
325                        ser.str (string("Mounting SD...",))
Addr : 00F5:             01  : Drop Anchor   
Addr : 00F6: PBASE Constant Address of Label0005
Addr : 00F6:       87 81 55  : Memory Op Byte PBASE + ADDRESS Address = 0155
Addr : 00F9:       06 21 0D  : Call Obj.Sub 33 13
326                        err := \sd.mount_explicit(spiDO,spiClk,spiDI,spiCS)    'Mount the SD
Addr : 00FC:             02  : Drop Anchor Push Try
Addr : 00FD:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 00FF:          38 1C  : Constant 1 Bytes - 1C - $0000001C 28
Addr : 0101:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0103:          38 0E  : Constant 1 Bytes - 0E - $0000000E 14
Addr : 0105:       06 22 10  : Call Obj.Sub 34 16
Addr : 0108:          A9 64  : Memory Op Word VBASE + WRITE Address = 0064
327                        ser.hex(err, 8)
Addr : 010A:             01  : Drop Anchor   
Addr : 010B:          A8 64  : Memory Op Word VBASE + READ Address = 0064
Addr : 010D:          37 02  : Constant Mask Y=2 00000008 8
Addr : 010F:       06 21 15  : Call Obj.Sub 33 21
328                        crlf
Addr : 0112:             01  : Drop Anchor   
Addr : 0113:          05 1D  : Call Sub 29   
330                        load_bytecode
Addr : 0115:             01  : Drop Anchor   
Addr : 0116:          05 03  : Call Sub 3    
336                        par_zpu_memory_addr := @zpu_memory
Addr : 0118:       87 80 90  : Memory Op Byte PBASE + ADDRESS Address = 0090
Addr : 011B:             41  : Variable Operation Global Offset - 0 Write
337                        par_zpu_memory_sz := zpu_memory_size
Addr : 011C:          37 0F  : Constant Mask Y=15 00010000 65536
Addr : 011E:             45  : Variable Operation Global Offset - 1 Write
338                        par_initial_pc := 0
Addr : 011F:             35  : Constant 1 $00000000
Addr : 0120:             49  : Variable Operation Global Offset - 2 Write
339                        par_initial_sp := zpu_memory_size - 8
Addr : 0121:          37 0F  : Constant Mask Y=15 00010000 65536
Addr : 0123:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0125:             ED  : Math Op -     
Addr : 0126:             4D  : Variable Operation Global Offset - 3 Write
340                        par_dispatch_tab_addr := zog.getdispatch_table
Addr : 0127:             00  : Drop Anchor Push 
Addr : 0128:       06 20 03  : Call Obj.Sub 32 3
Addr : 012B:             51  : Variable Operation Global Offset - 4 Write
341                        par_pasm_addr := zog.getzog
Addr : 012C:             00  : Drop Anchor Push 
Addr : 012D:       06 20 04  : Call Obj.Sub 32 4
Addr : 0130:             55  : Variable Operation Global Offset - 5 Write
342                        par_zog_mbox_addr := @zog_mbox_command
Addr : 0131:          CB 20  : Memory Op Long VBASE + ADDRESS Address = 0020
Addr : 0133:             59  : Variable Operation Global Offset - 6 Write
347                        par_vm_mbox_addr := @vm_mbox
Addr : 0134:          CB 40  : Memory Op Long VBASE + ADDRESS Address = 0040
Addr : 0136:             5D  : Variable Operation Global Offset - 7 Write
350                        zog.start(@par_zpu_memory_addr)                           'Start ZOG with parameter block
Addr : 0137:             01  : Drop Anchor   
Addr : 0138:             43  : Variable Operation Global Offset - 0 Address
Addr : 0139:       06 20 01  : Call Obj.Sub 32 1
351                        service_io                                                'Go any monitor ZPU I/O
Addr : 013C:             01  : Drop Anchor   
Addr : 013D:          05 05  : Call Sub 5    
Addr : 013F:             32  : Return        
Addr : 0140: Label0002
Addr : 0140: Data : 5A 4F 47 20 76 31 2E 35  ZOG v1.5
Addr : 0148: Data : 00                       .
Addr : 0149: Label0003
Addr : 0149: Data : 20 28 56 4D 29 00         (VM).
Addr : 014F: Label0004
Addr : 014F: Data : 53 74 61 72 74 69 6E 67  Starting
Addr : 0157: Data : 20 53 44 20 64 72 69 76   SD driv
Addr : 015F: Data : 65 72 2E 2E 2E 00        er....
Addr : 0165: Label0005
Addr : 0165: Data : 4D 6F 75 6E 74 69 6E 67  Mounting
Addr : 016D: Data : 20 53 44 2E 2E 2E 00      SD....
|===========================================================================|
Spin Block prime_vm with 0 Parameters and 3 Extra Stack Longs. Method 2
PUB prime_vm | vbyte, count, ramaddr

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - vbyte
Local Variable  DBASE:0008 - count
Local Variable  DBASE:000C - ramaddr
|===========================================================================|
492                        ser.str (string("Priming VM...", 13))
Addr : 0174:             01  : Drop Anchor   
Addr : 0175: PBASE Constant Address of Label0002
Addr : 0175:       87 81 AF  : Memory Op Byte PBASE + ADDRESS Address = 01AF
Addr : 0178:       06 21 0D  : Call Obj.Sub 33 13
493                        repeat count from 1 to 2
Addr : 017B:             36  : Constant 2 $00000001
Addr : 017C:             69  : Variable Operation Local Offset - 2 Write
Addr : 017D: Label0003
494                          repeat ramaddr from $FC00 to $FFFF
Addr : 017D:       39 FC 00  : Constant 2 Bytes - FC 00 - $0000FC00 64512
Addr : 0180:             6D  : Variable Operation Local Offset - 3 Write
Addr : 0181: Label0006
495                            vbyte := vm.rdvbyte(ramaddr ^ %11)
Addr : 0181:             00  : Drop Anchor Push 
Addr : 0182:             6C  : Variable Operation Local Offset - 3 Read
Addr : 0183:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 0185:             EB  : Math Op ^     
Addr : 0186:       06 23 02  : Call Obj.Sub 35 2
Addr : 0189:             65  : Variable Operation Local Offset - 1 Write
Addr : 018A: Label0007
494                          repeat ramaddr from $FC00 to $FFFF
Addr : 018A:       39 FC 00  : Constant 2 Bytes - FC 00 - $0000FC00 64512
Addr : 018D:          37 2F  : Constant Mask Y=47 Decrement 0000FFFF 65535
Addr : 018F: Repeat ramaddr Step Label0006
Addr : 018F:       6E 02 6F  : Variable Operation Local Offset - 3 Assign Repeat-Var loop Address= 0181 -17
Addr : 0192: Label0008
Addr : 0192: Label0004
493                        repeat count from 1 to 2
Addr : 0192:             36  : Constant 2 $00000001
Addr : 0193:          37 00  : Constant Mask Y=0 00000002 2
Addr : 0195: Repeat count Step Label0003
Addr : 0195:       6A 02 65  : Variable Operation Local Offset - 2 Assign Repeat-Var loop Address= 017D -27
Addr : 0198: Label0005
496                        repeat count from 1 to 1000
Addr : 0198:             36  : Constant 2 $00000001
Addr : 0199:             69  : Variable Operation Local Offset - 2 Write
Addr : 019A: Label0009
497                          repeat ramaddr from $05b9 to $05d5
Addr : 019A:       39 05 B9  : Constant 2 Bytes - 05 B9 - $000005B9 1465
Addr : 019D:             6D  : Variable Operation Local Offset - 3 Write
Addr : 019E: Label000C
498                            vbyte := vm.rdvbyte(ramaddr ^ %11)
Addr : 019E:             00  : Drop Anchor Push 
Addr : 019F:             6C  : Variable Operation Local Offset - 3 Read
Addr : 01A0:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 01A2:             EB  : Math Op ^     
Addr : 01A3:       06 23 02  : Call Obj.Sub 35 2
Addr : 01A6:             65  : Variable Operation Local Offset - 1 Write
Addr : 01A7: Label000D
497                          repeat ramaddr from $05b9 to $05d5
Addr : 01A7:       39 05 B9  : Constant 2 Bytes - 05 B9 - $000005B9 1465
Addr : 01AA:       39 05 D5  : Constant 2 Bytes - 05 D5 - $000005D5 1493
Addr : 01AD: Repeat ramaddr Step Label000C
Addr : 01AD:       6E 02 6E  : Variable Operation Local Offset - 3 Assign Repeat-Var loop Address= 019E -18
Addr : 01B0: Label000E
Addr : 01B0: Label000A
496                        repeat count from 1 to 1000
Addr : 01B0:             36  : Constant 2 $00000001
Addr : 01B1:       39 03 E8  : Constant 2 Bytes - 03 E8 - $000003E8 1000
Addr : 01B4: Repeat count Step Label0009
Addr : 01B4:       6A 02 63  : Variable Operation Local Offset - 2 Assign Repeat-Var loop Address= 019A -29
Addr : 01B7: Label000B
499                        ser.str (string("Done", 13))
Addr : 01B7:             01  : Drop Anchor   
Addr : 01B8: PBASE Constant Address of Label000F
Addr : 01B8:       87 81 BE  : Memory Op Byte PBASE + ADDRESS Address = 01BE
Addr : 01BB:       06 21 0D  : Call Obj.Sub 33 13
Addr : 01BE:             32  : Return        
Addr : 01BF: Label0002
Addr : 01BF: Data : 50 72 69 6D 69 6E 67 20  Priming 
Addr : 01C7: Data : 56 4D 2E 2E 2E 0D 00     VM.....
Addr : 01CE: Label000F
Addr : 01CE: Data : 44 6F 6E 65 0D 00        Done..
|===========================================================================|
Spin Block load_bytecode with 0 Parameters and 3 Extra Stack Longs. Method 3
PUB load_bytecode | bytes, i, ramaddr

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - bytes
Local Variable  DBASE:0008 - i
Local Variable  DBASE:000C - ramaddr
|===========================================================================|
504                        ser.str (string("Opening ZPU image...",))
Addr : 01D4:             01  : Drop Anchor   
Addr : 01D5: PBASE Constant Address of Label0002
Addr : 01D5:       87 82 37  : Memory Op Byte PBASE + ADDRESS Address = 0237
Addr : 01D8:       06 21 0D  : Call Obj.Sub 33 13
505                        err := \sd.popen(@filename, "r")
Addr : 01DB:             02  : Drop Anchor Push Try
Addr : 01DC:       87 80 90  : Memory Op Byte PBASE + ADDRESS Address = 0090
Addr : 01DF:          38 72  : Constant 1 Bytes - 72 - $00000072 114
Addr : 01E1:       06 22 13  : Call Obj.Sub 34 19
Addr : 01E4:          A9 64  : Memory Op Word VBASE + WRITE Address = 0064
506                        ser.hex(err, 8)
Addr : 01E6:             01  : Drop Anchor   
Addr : 01E7:          A8 64  : Memory Op Word VBASE + READ Address = 0064
Addr : 01E9:          37 02  : Constant Mask Y=2 00000008 8
Addr : 01EB:       06 21 15  : Call Obj.Sub 33 21
507                        crlf
Addr : 01EE:             01  : Drop Anchor   
Addr : 01EF:          05 1D  : Call Sub 29   
509                        ser.str (string("Reading image...",))
Addr : 01F1:             01  : Drop Anchor   
Addr : 01F2: PBASE Constant Address of Label0003
Addr : 01F2:       87 82 4C  : Memory Op Byte PBASE + ADDRESS Address = 024C
Addr : 01F5:       06 21 0D  : Call Obj.Sub 33 13
511                        bytes := 1
Addr : 01F8:             36  : Constant 2 $00000001
Addr : 01F9:             65  : Variable Operation Local Offset - 1 Write
Addr : 01FA: Label0004
512                        repeat while bytes > 0
Addr : 01FA:             64  : Variable Operation Local Offset - 1 Read
Addr : 01FB:             35  : Constant 1 $00000000
Addr : 01FC:             FA  : Math Op >     
Addr : 01FD: JZ Label0006
Addr : 01FD:          0A 32  : jz Address = 0231 50
513                          bytes := sd.pread(@diskbuff, 512)
Addr : 01FF:             00  : Drop Anchor Push 
Addr : 0200:          8B 66  : Memory Op Byte VBASE + ADDRESS Address = 0066
Addr : 0202:          37 08  : Constant Mask Y=8 00000200 512
Addr : 0204:       06 22 14  : Call Obj.Sub 34 20
Addr : 0207:             65  : Variable Operation Local Offset - 1 Write
514                          err := sd.stopSDCard                                'Stop SD card, but do not stop cog
Addr : 0208:             00  : Drop Anchor Push 
Addr : 0209:       06 22 06  : Call Obj.Sub 34 6
Addr : 020C:          A9 64  : Memory Op Word VBASE + WRITE Address = 0064
515                          repeat i from 0 to bytes - 1
Addr : 020E:             35  : Constant 1 $00000000
Addr : 020F:             69  : Variable Operation Local Offset - 2 Write
Addr : 0210: Label0007
516                            vm.wrvbyte(ramaddr, diskbuff[i])                  'To virtual memory.
Addr : 0210:             01  : Drop Anchor   
Addr : 0211:             6C  : Variable Operation Local Offset - 3 Read
Addr : 0212:             68  : Variable Operation Local Offset - 2 Read
Addr : 0213:          98 66  : Memory Op Byte VBASE + POP Index READ Address = 0066
Addr : 0215:       06 23 05  : Call Obj.Sub 35 5
517                            ramaddr++
Addr : 0218:          6E 2E  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long
Addr : 021A: Label0008
515                          repeat i from 0 to bytes - 1
Addr : 021A:             35  : Constant 1 $00000000
Addr : 021B:             64  : Variable Operation Local Offset - 1 Read
Addr : 021C:             36  : Constant 2 $00000001
Addr : 021D:             ED  : Math Op -     
Addr : 021E: Repeat i Step Label0007
Addr : 021E:       6A 02 6F  : Variable Operation Local Offset - 2 Assign Repeat-Var loop Address= 0210 -17
Addr : 0221: Label0009
518                          err := \sd.initSDCard(spiDO,spiClk,spiDI,spiCS)     'Init the SD
Addr : 0221:             02  : Drop Anchor Push Try
Addr : 0222:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 0224:          38 1C  : Constant 1 Bytes - 1C - $0000001C 28
Addr : 0226:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0228:          38 0E  : Constant 1 Bytes - 0E - $0000000E 14
Addr : 022A:       06 22 05  : Call Obj.Sub 34 5
Addr : 022D:          A9 64  : Memory Op Word VBASE + WRITE Address = 0064
Addr : 022F: Label0005
Addr : 022F: JMP Label0004
Addr : 022F:          04 49  : Jmp 01FA -55  
Addr : 0231: Label0006
519                        ser.str (string("Done",))
Addr : 0231:             01  : Drop Anchor   
Addr : 0232: PBASE Constant Address of Label000A
Addr : 0232:       87 82 5D  : Memory Op Byte PBASE + ADDRESS Address = 025D
Addr : 0235:       06 21 0D  : Call Obj.Sub 33 13
520                        crlf
Addr : 0238:             01  : Drop Anchor   
Addr : 0239:          05 1D  : Call Sub 29   
522                        err := sd.stopSDCard                                  'stop SD card, but do not stop cog
Addr : 023B:             00  : Drop Anchor Push 
Addr : 023C:       06 22 06  : Call Obj.Sub 34 6
Addr : 023F:          A9 64  : Memory Op Word VBASE + WRITE Address = 0064
523                        CheckError(err)
Addr : 0241:             01  : Drop Anchor   
Addr : 0242:          A8 64  : Memory Op Word VBASE + READ Address = 0064
Addr : 0244:          05 1E  : Call Sub 30   
Addr : 0246:             32  : Return        
Addr : 0247: Label0002
Addr : 0247: Data : 4F 70 65 6E 69 6E 67 20  Opening 
Addr : 024F: Data : 5A 50 55 20 69 6D 61 67  ZPU imag
Addr : 0257: Data : 65 2E 2E 2E 00           e....
Addr : 025C: Label0003
Addr : 025C: Data : 52 65 61 64 69 6E 67 20  Reading 
Addr : 0264: Data : 69 6D 61 67 65 2E 2E 2E  image...
Addr : 026C: Data : 00                       .
Addr : 026D: Label000A
Addr : 026D: Data : 44 6F 6E 65 00           Done.
|===========================================================================|
Spin Block dump_virtual with 0 Parameters and 4 Extra Stack Longs. Method 4
PRI dump_virtual | ad, b, i, e

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - ad
Local Variable  DBASE:0008 - b
Local Variable  DBASE:000C - i
Local Variable  DBASE:0010 - e
|===========================================================================|
526                        ser.str(string("Reading virtual memory...",13))
Addr : 0272:             01  : Drop Anchor   
Addr : 0273: PBASE Constant Address of Label0002
Addr : 0273:       87 82 C0  : Memory Op Byte PBASE + ADDRESS Address = 02C0
Addr : 0276:       06 21 0D  : Call Obj.Sub 33 13
527                        i := 0
Addr : 0279:             35  : Constant 1 $00000000
Addr : 027A:             6D  : Variable Operation Local Offset - 3 Write
528                        e := 0
Addr : 027B:             35  : Constant 1 $00000000
Addr : 027C:             71  : Variable Operation Local Offset - 4 Write
529                        repeat ad from 0 to 255  'zpu_memory_size - 1 step 1
Addr : 027D:             35  : Constant 1 $00000000
Addr : 027E:             65  : Variable Operation Local Offset - 1 Write
Addr : 027F: Label0003
530                          if (i & 15) == 0
Addr : 027F:             6C  : Variable Operation Local Offset - 3 Read
Addr : 0280:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 0282:             E8  : Math Op &     
Addr : 0283:             35  : Constant 1 $00000000
Addr : 0284:             FC  : Math Op ==    
Addr : 0285: JZ Label0006
Addr : 0285:          0A 13  : jz Address = 029A 19
531                            ser.hex(ad,4)
Addr : 0287:             01  : Drop Anchor   
Addr : 0288:             64  : Variable Operation Local Offset - 1 Read
Addr : 0289:          37 01  : Constant Mask Y=1 00000004 4
Addr : 028B:       06 21 15  : Call Obj.Sub 33 21
532                            ser.tx(":")
Addr : 028E:             01  : Drop Anchor   
Addr : 028F:          38 3A  : Constant 1 Bytes - 3A - $0000003A 58
Addr : 0291:       06 21 04  : Call Obj.Sub 33 4
533                            ser.tx(" ")
Addr : 0294:             01  : Drop Anchor   
Addr : 0295:          37 04  : Constant Mask Y=4 00000020 32
Addr : 0297:       06 21 04  : Call Obj.Sub 33 4
Addr : 029A: Label0006
Addr : 029A: Label0007
534                          b:=vm.rdvbyte(ad ^ %11)                             'XOR here is an endiannes fix
Addr : 029A:             00  : Drop Anchor Push 
Addr : 029B:             64  : Variable Operation Local Offset - 1 Read
Addr : 029C:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 029E:             EB  : Math Op ^     
Addr : 029F:       06 23 02  : Call Obj.Sub 35 2
Addr : 02A2:             69  : Variable Operation Local Offset - 2 Write
535                          ser.hex(b,2)
Addr : 02A3:             01  : Drop Anchor   
Addr : 02A4:             68  : Variable Operation Local Offset - 2 Read
Addr : 02A5:          37 00  : Constant Mask Y=0 00000002 2
Addr : 02A7:       06 21 15  : Call Obj.Sub 33 21
536                          ser.tx($20)
Addr : 02AA:             01  : Drop Anchor   
Addr : 02AB:          37 04  : Constant Mask Y=4 00000020 32
Addr : 02AD:       06 21 04  : Call Obj.Sub 33 4
537                          i := i + 1
Addr : 02B0:             6C  : Variable Operation Local Offset - 3 Read
Addr : 02B1:             36  : Constant 2 $00000001
Addr : 02B2:             EC  : Math Op +     
Addr : 02B3:             6D  : Variable Operation Local Offset - 3 Write
538                          if i == 16
Addr : 02B4:             6C  : Variable Operation Local Offset - 3 Read
Addr : 02B5:          37 03  : Constant Mask Y=3 00000010 16
Addr : 02B7:             FC  : Math Op ==    
Addr : 02B8: JZ Label0008
Addr : 02B8:          0A 0E  : jz Address = 02C8 14
539                            ser.tx(13)
Addr : 02BA:             01  : Drop Anchor   
Addr : 02BB:          38 0D  : Constant 1 Bytes - 0D - $0000000D 13
Addr : 02BD:       06 21 04  : Call Obj.Sub 33 4
540                            ser.tx(10)
Addr : 02C0:             01  : Drop Anchor   
Addr : 02C1:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 02C3:       06 21 04  : Call Obj.Sub 33 4
541                            i := 0
Addr : 02C6:             35  : Constant 1 $00000000
Addr : 02C7:             6D  : Variable Operation Local Offset - 3 Write
Addr : 02C8: Label0008
Addr : 02C8: Label0009
Addr : 02C8: Label0004
529                        repeat ad from 0 to 255  'zpu_memory_size - 1 step 1
Addr : 02C8:             35  : Constant 1 $00000000
Addr : 02C9:          37 27  : Constant Mask Y=39 Decrement 000000FF 255
Addr : 02CB: Repeat ad Step Label0003
Addr : 02CB:    66 02 FF B0  : Variable Operation Local Offset - 1 Assign Repeat-Var loop Address= 027F -80
Addr : 02CF: Label0005
Addr : 02CF:             32  : Return        
Addr : 02D0: Label0002
Addr : 02D0: Data : 52 65 61 64 69 6E 67 20  Reading 
Addr : 02D8: Data : 76 69 72 74 75 61 6C 20  virtual 
Addr : 02E0: Data : 6D 65 6D 6F 72 79 2E 2E  memory..
Addr : 02E8: Data : 2E 0D 00                 ...
|===========================================================================|
Spin Block service_io with 0 Parameters and 0 Extra Stack Longs. Method 5
PRI service_io

Local Parameter DBASE:0000 - Result
|===========================================================================|
547                        repeat
Addr : 02EB: Label0002
Addr : 02EB: Constant Address of Label0005
Addr : 02EB:       39 03 00  : Constant 2 Bytes - 03 00 - $00000300 768
548                          case zog_mbox_command
Addr : 02EE:          C8 20  : Memory Op Long VBASE + READ Address = 0020
549                            io_cmd_break:                                     'CPU break
Addr : 02F0:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 02F2: Case_Value Label0006
Addr : 02F2:          0D 0C  : Value Case Address = 0300 12
551                            io_cmd_in:                                        'An input operation
Addr : 02F4:          37 00  : Constant Mask Y=0 00000002 2
Addr : 02F6: Case_Value Label0007
Addr : 02F6:          0D 0C  : Value Case Address = 0304 12
553                            io_cmd_out:                                       'An output operation
Addr : 02F8:             36  : Constant 2 $00000001
Addr : 02F9: Case_Value Label0008
Addr : 02F9:          0D 0D  : Value Case Address = 0308 13
555                            io_cmd_syscall:
Addr : 02FB:          37 01  : Constant Mask Y=1 00000004 4
Addr : 02FD: Case_Value Label0009
Addr : 02FD:          0D 0D  : Value Case Address = 030C 13
Addr : 02FF: CaseDone Label0009
Addr : 02FF:             0C  : Casedone      
Addr : 0300: Label0006
550                              on_break
Addr : 0300:             01  : Drop Anchor   
Addr : 0301:          05 08  : Call Sub 8    
Addr : 0303: CaseDone Label0006
Addr : 0303:             0C  : Casedone      
Addr : 0304: Label0007
552                              on_input
Addr : 0304:             01  : Drop Anchor   
Addr : 0305:          05 06  : Call Sub 6    
Addr : 0307: CaseDone Label0007
Addr : 0307:             0C  : Casedone      
Addr : 0308: Label0008
554                              on_output
Addr : 0308:             01  : Drop Anchor   
Addr : 0309:          05 07  : Call Sub 7    
Addr : 030B: CaseDone Label0008
Addr : 030B:             0C  : Casedone      
Addr : 030C: Label0009
556                              on_syscall
Addr : 030C:             01  : Drop Anchor   
Addr : 030D:          05 0A  : Call Sub 10   
Addr : 030F: CaseDone Label0009
Addr : 030F:             0C  : Casedone      
Addr : 0310: Label0005
Addr : 0310: Label0003
Addr : 0310: JMP Label0002
Addr : 0310:          04 59  : Jmp 02EB -39  
Addr : 0312: Label0004
Addr : 0312:             32  : Return        
|===========================================================================|
Spin Block on_input with 0 Parameters and 0 Extra Stack Longs. Method 6
PRI on_input

Local Parameter DBASE:0000 - Result
|===========================================================================|
564                        case zog_mbox_port
Addr : 0313: Constant Address of Label0002
Addr : 0313:       39 03 38  : Constant 2 Bytes - 03 38 - $00000338 824
Addr : 0316:          C8 24  : Memory Op Long VBASE + READ Address = 0024
565                          UART_TX_PORT:
Addr : 0318: 3B 80 00 00 24  : Constant 4 Bytes - 80 00 00 24 - $80000024 2147483684
Addr : 031D: Case_Value Label0003
Addr : 031D:          0D 1A  : Value Case Address = 0339 26
567                          UART_RX_PORT:
Addr : 031F: 3B 80 00 00 28  : Constant 4 Bytes - 80 00 00 28 - $80000028 2147483688
Addr : 0324: Case_Value Label0004
Addr : 0324:          0D 18  : Value Case Address = 033E 24
570                            ser.str(string("Read from unknown input port "))
Addr : 0326:             01  : Drop Anchor   
Addr : 0327: PBASE Constant Address of Label0005
Addr : 0327:       87 83 3C  : Memory Op Byte PBASE + ADDRESS Address = 033C
Addr : 032A:       06 21 0D  : Call Obj.Sub 33 13
571                            ser.hex(zog_mbox_port, 8)
Addr : 032D:             01  : Drop Anchor   
Addr : 032E:          C8 24  : Memory Op Long VBASE + READ Address = 0024
Addr : 0330:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0332:       06 21 15  : Call Obj.Sub 33 21
572                            crlf
Addr : 0335:             01  : Drop Anchor   
Addr : 0336:          05 1D  : Call Sub 29   
Addr : 0338: CaseDone Label0004
Addr : 0338:             0C  : Casedone      
Addr : 0339: Label0003
566                            zog_mbox_data := $100
Addr : 0339:          37 07  : Constant Mask Y=7 00000100 256
Addr : 033B:          C9 28  : Memory Op Long VBASE + WRITE Address = 0028
Addr : 033D: CaseDone Label0003
Addr : 033D:             0C  : Casedone      
Addr : 033E: Label0004
568                            zog_mbox_data := ser.rx + $100
Addr : 033E:             00  : Drop Anchor Push 
Addr : 033F:       06 21 05  : Call Obj.Sub 33 5
Addr : 0342:          37 07  : Constant Mask Y=7 00000100 256
Addr : 0344:             EC  : Math Op +     
Addr : 0345:          C9 28  : Memory Op Long VBASE + WRITE Address = 0028
Addr : 0347: CaseDone Label0004
Addr : 0347:             0C  : Casedone      
Addr : 0348: Label0002
573                        zog_mbox_command := 0
Addr : 0348:             35  : Constant 1 $00000000
Addr : 0349:          C9 20  : Memory Op Long VBASE + WRITE Address = 0020
Addr : 034B:             32  : Return        
Addr : 034C: Label0005
Addr : 034C: Data : 52 65 61 64 20 66 72 6F  Read fro
Addr : 0354: Data : 6D 20 75 6E 6B 6E 6F 77  m unknow
Addr : 035C: Data : 6E 20 69 6E 70 75 74 20  n input 
Addr : 0364: Data : 70 6F 72 74 20 00        port .
|===========================================================================|
Spin Block on_output with 0 Parameters and 0 Extra Stack Longs. Method 7
PRI on_output

Local Parameter DBASE:0000 - Result
|===========================================================================|
576                        case zog_mbox_port
Addr : 036A: Constant Address of Label0002
Addr : 036A:       39 03 8F  : Constant 2 Bytes - 03 8F - $0000038F 911
Addr : 036D:          C8 24  : Memory Op Long VBASE + READ Address = 0024
577                          UART_TX_PORT:
Addr : 036F: 3B 80 00 00 24  : Constant 4 Bytes - 80 00 00 24 - $80000024 2147483684
Addr : 0374: Case_Value Label0003
Addr : 0374:          0D 22  : Value Case Address = 0398 34
580                            ser.str(string("Write to unknown output port "))
Addr : 0376:             01  : Drop Anchor   
Addr : 0377: PBASE Constant Address of Label0004
Addr : 0377:       87 83 93  : Memory Op Byte PBASE + ADDRESS Address = 0393
Addr : 037A:       06 21 0D  : Call Obj.Sub 33 13
581                            ser.hex(zog_mbox_port, 8)
Addr : 037D:             01  : Drop Anchor   
Addr : 037E:          C8 24  : Memory Op Long VBASE + READ Address = 0024
Addr : 0380:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0382:       06 21 15  : Call Obj.Sub 33 21
582                            ser.str(string(" : "))
Addr : 0385:             01  : Drop Anchor   
Addr : 0386: PBASE Constant Address of Label0005
Addr : 0386:       87 83 B1  : Memory Op Byte PBASE + ADDRESS Address = 03B1
Addr : 0389:       06 21 0D  : Call Obj.Sub 33 13
583                            ser.hex(zog_mbox_data, 8)
Addr : 038C:             01  : Drop Anchor   
Addr : 038D:          C8 28  : Memory Op Long VBASE + READ Address = 0028
Addr : 038F:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0391:       06 21 15  : Call Obj.Sub 33 21
584                            crlf
Addr : 0394:             01  : Drop Anchor   
Addr : 0395:          05 1D  : Call Sub 29   
Addr : 0397: CaseDone Label0003
Addr : 0397:             0C  : Casedone      
Addr : 0398: Label0003
578                            ser.tx(zog_mbox_data)
Addr : 0398:             01  : Drop Anchor   
Addr : 0399:          C8 28  : Memory Op Long VBASE + READ Address = 0028
Addr : 039B:       06 21 04  : Call Obj.Sub 33 4
Addr : 039E: CaseDone Label0003
Addr : 039E:             0C  : Casedone      
Addr : 039F: Label0002
585                        zog_mbox_command := 0
Addr : 039F:             35  : Constant 1 $00000000
Addr : 03A0:          C9 20  : Memory Op Long VBASE + WRITE Address = 0020
Addr : 03A2:             32  : Return        
Addr : 03A3: Label0004
Addr : 03A3: Data : 57 72 69 74 65 20 74 6F  Write to
Addr : 03AB: Data : 20 75 6E 6B 6E 6F 77 6E   unknown
Addr : 03B3: Data : 20 6F 75 74 70 75 74 20   output 
Addr : 03BB: Data : 70 6F 72 74 20 00        port .
Addr : 03C1: Label0005
Addr : 03C1: Data : 20 3A 20 00               : .
|===========================================================================|
Spin Block on_break with 0 Parameters and 0 Extra Stack Longs. Method 8
PRI on_break

Local Parameter DBASE:0000 - Result
|===========================================================================|
589                        if step_count == 0
Addr : 03C5:          C8 60  : Memory Op Long VBASE + READ Address = 0060
Addr : 03C7:             35  : Constant 1 $00000000
Addr : 03C8:             FC  : Math Op ==    
Addr : 03C9: JZ Label0002
Addr : 03C9:          0A 1A  : jz Address = 03E5 26
590                          crlf
Addr : 03CB:             01  : Drop Anchor   
Addr : 03CC:          05 1D  : Call Sub 29   
591                          ser.str(string("#pc,opcode,sp,top_of_stack,next_on_stack"))
Addr : 03CE:             01  : Drop Anchor   
Addr : 03CF: PBASE Constant Address of Label0004
Addr : 03CF:       87 83 FC  : Memory Op Byte PBASE + ADDRESS Address = 03FC
Addr : 03D2:       06 21 0D  : Call Obj.Sub 33 13
592                          crlf
Addr : 03D5:             01  : Drop Anchor   
Addr : 03D6:          05 1D  : Call Sub 29   
593                          ser.str(string("#----------"))
Addr : 03D8:             01  : Drop Anchor   
Addr : 03D9: PBASE Constant Address of Label0005
Addr : 03D9:       87 84 25  : Memory Op Byte PBASE + ADDRESS Address = 0425
Addr : 03DC:       06 21 0D  : Call Obj.Sub 33 13
594                          crlf
Addr : 03DF:             01  : Drop Anchor   
Addr : 03E0:          05 1D  : Call Sub 29   
595                          crlf
Addr : 03E2:             01  : Drop Anchor   
Addr : 03E3:          05 1D  : Call Sub 29   
Addr : 03E5: Label0002
Addr : 03E5: Label0003
596                        print_regs
Addr : 03E5:             01  : Drop Anchor   
Addr : 03E6:          05 1C  : Call Sub 28   
Addr : 03E8: Label0006
598                        repeat while ser.rx <> $20                           'Wait for 'space'
Addr : 03E8:             00  : Drop Anchor Push 
Addr : 03E9:       06 21 05  : Call Obj.Sub 33 5
Addr : 03EC:          37 04  : Constant Mask Y=4 00000020 32
Addr : 03EE:             FB  : Math Op <>    
Addr : 03EF: JZ Label0008
Addr : 03EF:          0A 02  : jz Address = 03F3 2
Addr : 03F1: Label0007
Addr : 03F1: JMP Label0006
Addr : 03F1:          04 75  : Jmp 03E8 -11  
Addr : 03F3: Label0008
599                        zog_mbox_command := 0
Addr : 03F3:             35  : Constant 1 $00000000
Addr : 03F4:          C9 20  : Memory Op Long VBASE + WRITE Address = 0020
600                        if step_count++ == 1000
Addr : 03F6:       CA 60 AE  : Memory Op Long VBASE + ASSIGN Address = 0060 VAR++ post inc Long Push
Addr : 03F9:       39 03 E8  : Constant 2 Bytes - 03 E8 - $000003E8 1000
Addr : 03FC:             FC  : Math Op ==    
Addr : 03FD: JZ Label0009
Addr : 03FD:          0A 0C  : jz Address = 040B 12
601                          ser.str(string("Done."))
Addr : 03FF:             01  : Drop Anchor   
Addr : 0400: PBASE Constant Address of Label000B
Addr : 0400:       87 84 31  : Memory Op Byte PBASE + ADDRESS Address = 0431
Addr : 0403:       06 21 0D  : Call Obj.Sub 33 13
602                          crlf
Addr : 0406:             01  : Drop Anchor   
Addr : 0407:          05 1D  : Call Sub 29   
Addr : 0409: Label000C
Addr : 0409: Label000D
Addr : 0409: JMP Label000C
Addr : 0409:          04 7E  : Jmp 0409 -2   
Addr : 040B: Label000E
Addr : 040B: Label0009
Addr : 040B: Label000A
Addr : 040B:             32  : Return        
Addr : 040C: Label0004
Addr : 040C: Data : 23 70 63 2C 6F 70 63 6F  #pc,opco
Addr : 0414: Data : 64 65 2C 73 70 2C 74 6F  de,sp,to
Addr : 041C: Data : 70 5F 6F 66 5F 73 74 61  p_of_sta
Addr : 0424: Data : 63 6B 2C 6E 65 78 74 5F  ck,next_
Addr : 042C: Data : 6F 6E 5F 73 74 61 63 6B  on_stack
Addr : 0434: Data : 00                       .
Addr : 0435: Label0005
Addr : 0435: Data : 23 2D 2D 2D 2D 2D 2D 2D  #-------
Addr : 043D: Data : 2D 2D 2D 00              ---.
Addr : 0441: Label000B
Addr : 0441: Data : 44 6F 6E 65 2E 00        Done..
|===========================================================================|
Spin Block printStackFrame with 0 Parameters and 2 Extra Stack Longs. Method 9
PRI printStackFrame | buff, i

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - buff
Local Variable  DBASE:0008 - i
|===========================================================================|
607                        ser.str(string("Return address="))
Addr : 0447:             01  : Drop Anchor   
Addr : 0448: PBASE Constant Address of Label0002
Addr : 0448:       87 84 BB  : Memory Op Byte PBASE + ADDRESS Address = 04BB
Addr : 044B:       06 21 0D  : Call Obj.Sub 33 13
608                        ser.hex(long[framep + 0], 8)
Addr : 044E:             01  : Drop Anchor   
Addr : 044F:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 0451:             35  : Constant 1 $00000000
Addr : 0452:             EC  : Math Op +     
Addr : 0453:             C0  : Memory Op Long POP Address READ 
Addr : 0454:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0456:       06 21 15  : Call Obj.Sub 33 21
609                        crlf
Addr : 0459:             01  : Drop Anchor   
Addr : 045A:          05 1D  : Call Sub 29   
610                        ser.str(string("errno address="))
Addr : 045C:             01  : Drop Anchor   
Addr : 045D: PBASE Constant Address of Label0003
Addr : 045D:       87 84 CB  : Memory Op Byte PBASE + ADDRESS Address = 04CB
Addr : 0460:       06 21 0D  : Call Obj.Sub 33 13
611                        ser.hex(long[framep + 4], 8)
Addr : 0463:             01  : Drop Anchor   
Addr : 0464:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 0466:          37 01  : Constant Mask Y=1 00000004 4
Addr : 0468:             EC  : Math Op +     
Addr : 0469:             C0  : Memory Op Long POP Address READ 
Addr : 046A:          37 02  : Constant Mask Y=2 00000008 8
Addr : 046C:       06 21 15  : Call Obj.Sub 33 21
612                        crlf
Addr : 046F:             01  : Drop Anchor   
Addr : 0470:          05 1D  : Call Sub 29   
613                        ser.str(string("syscall ID="))
Addr : 0472:             01  : Drop Anchor   
Addr : 0473: PBASE Constant Address of Label0004
Addr : 0473:       87 84 DA  : Memory Op Byte PBASE + ADDRESS Address = 04DA
Addr : 0476:       06 21 0D  : Call Obj.Sub 33 13
614                        ser.hex(long[framep + 8], 8)
Addr : 0479:             01  : Drop Anchor   
Addr : 047A:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 047C:          37 02  : Constant Mask Y=2 00000008 8
Addr : 047E:             EC  : Math Op +     
Addr : 047F:             C0  : Memory Op Long POP Address READ 
Addr : 0480:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0482:       06 21 15  : Call Obj.Sub 33 21
615                        crlf
Addr : 0485:             01  : Drop Anchor   
Addr : 0486:          05 1D  : Call Sub 29   
616                        ser.str(string("fd="))
Addr : 0488:             01  : Drop Anchor   
Addr : 0489: PBASE Constant Address of Label0005
Addr : 0489:       87 84 E6  : Memory Op Byte PBASE + ADDRESS Address = 04E6
Addr : 048C:       06 21 0D  : Call Obj.Sub 33 13
617                        ser.hex(long[framep + 12], 8)
Addr : 048F:             01  : Drop Anchor   
Addr : 0490:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 0492:          38 0C  : Constant 1 Bytes - 0C - $0000000C 12
Addr : 0494:             EC  : Math Op +     
Addr : 0495:             C0  : Memory Op Long POP Address READ 
Addr : 0496:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0498:       06 21 15  : Call Obj.Sub 33 21
618                        crlf
Addr : 049B:             01  : Drop Anchor   
Addr : 049C:          05 1D  : Call Sub 29   
619                        ser.str(string("buff="))
Addr : 049E:             01  : Drop Anchor   
Addr : 049F: PBASE Constant Address of Label0006
Addr : 049F:       87 84 EA  : Memory Op Byte PBASE + ADDRESS Address = 04EA
Addr : 04A2:       06 21 0D  : Call Obj.Sub 33 13
620                        ser.hex(long[framep + 16], 8)
Addr : 04A5:             01  : Drop Anchor   
Addr : 04A6:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 04A8:          37 03  : Constant Mask Y=3 00000010 16
Addr : 04AA:             EC  : Math Op +     
Addr : 04AB:             C0  : Memory Op Long POP Address READ 
Addr : 04AC:          37 02  : Constant Mask Y=2 00000008 8
Addr : 04AE:       06 21 15  : Call Obj.Sub 33 21
621                        crlf
Addr : 04B1:             01  : Drop Anchor   
Addr : 04B2:          05 1D  : Call Sub 29   
622                        ser.str(string("length="))
Addr : 04B4:             01  : Drop Anchor   
Addr : 04B5: PBASE Constant Address of Label0007
Addr : 04B5:       87 84 F0  : Memory Op Byte PBASE + ADDRESS Address = 04F0
Addr : 04B8:       06 21 0D  : Call Obj.Sub 33 13
623                        ser.hex(long[framep + 20], 8)
Addr : 04BB:             01  : Drop Anchor   
Addr : 04BC:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 04BE:          38 14  : Constant 1 Bytes - 14 - $00000014 20
Addr : 04C0:             EC  : Math Op +     
Addr : 04C1:             C0  : Memory Op Long POP Address READ 
Addr : 04C2:          37 02  : Constant Mask Y=2 00000008 8
Addr : 04C4:       06 21 15  : Call Obj.Sub 33 21
624                        crlf
Addr : 04C7:             01  : Drop Anchor   
Addr : 04C8:          05 1D  : Call Sub 29   
Addr : 04CA:             32  : Return        
Addr : 04CB: Label0002
Addr : 04CB: Data : 52 65 74 75 72 6E 20 61  Return a
Addr : 04D3: Data : 64 64 72 65 73 73 3D 00  ddress=.
Addr : 04DB: Data :                          
Addr : 04DB: Label0003
Addr : 04DB: Data : 65 72 72 6E 6F 20 61 64  errno ad
Addr : 04E3: Data : 64 72 65 73 73 3D 00     dress=.
Addr : 04EA: Label0004
Addr : 04EA: Data : 73 79 73 63 61 6C 6C 20  syscall 
Addr : 04F2: Data : 49 44 3D 00              ID=.
Addr : 04F6: Label0005
Addr : 04F6: Data : 66 64 3D 00              fd=.
Addr : 04FA: Label0006
Addr : 04FA: Data : 62 75 66 66 3D 00        buff=.
Addr : 0500: Label0007
Addr : 0500: Data : 6C 65 6E 67 74 68 3D 00  length=.
Addr : 0508: Data :                          
|===========================================================================|
Spin Block on_syscall with 0 Parameters and 1 Extra Stack Longs. Method 10
PRI on_syscall | p

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - p
|===========================================================================|
632                        framep := zog_mbox_sp + @zpu_memory
Addr : 0508:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 050A:       87 80 90  : Memory Op Byte PBASE + ADDRESS Address = 0090
Addr : 050D:             EC  : Math Op +     
Addr : 050E:          C9 5C  : Memory Op Long VBASE + WRITE Address = 005C
Addr : 0510: Constant Address of Label0002
Addr : 0510:       39 05 A2  : Constant 2 Bytes - 05 A2 - $000005A2 1442
635                        case long[framep + 8]
Addr : 0513:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 0515:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0517:             EC  : Math Op +     
Addr : 0518:             C0  : Memory Op Long POP Address READ 
636                          SYS_exit:
Addr : 0519:             36  : Constant 2 $00000001
Addr : 051A: Case_Value Label0003
Addr : 051A:       0D 80 51  : Value Case Address = 056E 81
638                          SYS_open:
Addr : 051D:          37 00  : Constant Mask Y=0 00000002 2
Addr : 051F: Case_Value Label0004
Addr : 051F:       0D 80 50  : Value Case Address = 0572 80
640                          SYS_close:
Addr : 0522:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 0524: Case_Value Label0005
Addr : 0524:       0D 80 4F  : Value Case Address = 0576 79
642                          SYS_read:
Addr : 0527:          37 01  : Constant Mask Y=1 00000004 4
Addr : 0529: Case_Value Label0006
Addr : 0529:       0D 80 4E  : Value Case Address = 057A 78
644                          SYS_write:
Addr : 052C:          38 05  : Constant 1 Bytes - 05 - $00000005 5
Addr : 052E: Case_Value Label0007
Addr : 052E:       0D 80 4D  : Value Case Address = 057E 77
646                          SYS_lseek:
Addr : 0531:          38 06  : Constant 1 Bytes - 06 - $00000006 6
Addr : 0533: Case_Value Label0008
Addr : 0533:       0D 80 4C  : Value Case Address = 0582 76
648                          SYS_unlink:
Addr : 0536:          37 22  : Constant Mask Y=34 Decrement 00000007 7
Addr : 0538: Case_Value Label0009
Addr : 0538:       0D 80 4B  : Value Case Address = 0586 75
650                          SYS_getpid:
Addr : 053B:          37 02  : Constant Mask Y=2 00000008 8
Addr : 053D: Case_Value Label000A
Addr : 053D:       0D 80 4A  : Value Case Address = 058A 74
652                          SYS_kill:
Addr : 0540:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 0542: Case_Value Label000B
Addr : 0542:       0D 80 49  : Value Case Address = 058E 73
654                          SYS_fstat:
Addr : 0545:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 0547: Case_Value Label000C
Addr : 0547:       0D 80 48  : Value Case Address = 0592 72
656                          SYS_argvlen:
Addr : 054A:          38 0C  : Constant 1 Bytes - 0C - $0000000C 12
Addr : 054C: Case_Value Label000D
Addr : 054C:       0D 80 47  : Value Case Address = 0596 71
658                          SYS_argv:
Addr : 054F:          38 0D  : Constant 1 Bytes - 0D - $0000000D 13
Addr : 0551: Case_Value Label000E
Addr : 0551:       0D 80 46  : Value Case Address = 059A 70
660                          SYS_chdir:
Addr : 0554:          38 0E  : Constant 1 Bytes - 0E - $0000000E 14
Addr : 0556: Case_Value Label000F
Addr : 0556:       0D 80 45  : Value Case Address = 059E 69
662                          SYS_stat:
Addr : 0559:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 055B: Case_Value Label0010
Addr : 055B:       0D 80 44  : Value Case Address = 05A2 68
664                          SYS_chmod:
Addr : 055E:          37 03  : Constant Mask Y=3 00000010 16
Addr : 0560: Case_Value Label0011
Addr : 0560:       0D 80 43  : Value Case Address = 05A6 67
666                          SYS_utime:
Addr : 0563:          38 11  : Constant 1 Bytes - 11 - $00000011 17
Addr : 0565: Case_Value Label0012
Addr : 0565:       0D 80 42  : Value Case Address = 05AA 66
668                          SYS_time:
Addr : 0568:          38 12  : Constant 1 Bytes - 12 - $00000012 18
Addr : 056A: Case_Value Label0013
Addr : 056A:       0D 80 41  : Value Case Address = 05AE 65
Addr : 056D: CaseDone Label0013
Addr : 056D:             0C  : Casedone      
Addr : 056E: Label0003
637                            _exit
Addr : 056E:             01  : Drop Anchor   
Addr : 056F:          05 0B  : Call Sub 11   
Addr : 0571: CaseDone Label0003
Addr : 0571:             0C  : Casedone      
Addr : 0572: Label0004
639                            _open
Addr : 0572:             01  : Drop Anchor   
Addr : 0573:          05 0C  : Call Sub 12   
Addr : 0575: CaseDone Label0004
Addr : 0575:             0C  : Casedone      
Addr : 0576: Label0005
641                            _close
Addr : 0576:             01  : Drop Anchor   
Addr : 0577:          05 0D  : Call Sub 13   
Addr : 0579: CaseDone Label0005
Addr : 0579:             0C  : Casedone      
Addr : 057A: Label0006
643                            _read
Addr : 057A:             01  : Drop Anchor   
Addr : 057B:          05 0E  : Call Sub 14   
Addr : 057D: CaseDone Label0006
Addr : 057D:             0C  : Casedone      
Addr : 057E: Label0007
645                            _write
Addr : 057E:             01  : Drop Anchor   
Addr : 057F:          05 0F  : Call Sub 15   
Addr : 0581: CaseDone Label0007
Addr : 0581:             0C  : Casedone      
Addr : 0582: Label0008
647                            _lseek
Addr : 0582:             01  : Drop Anchor   
Addr : 0583:          05 10  : Call Sub 16   
Addr : 0585: CaseDone Label0008
Addr : 0585:             0C  : Casedone      
Addr : 0586: Label0009
649                            _unlink
Addr : 0586:             01  : Drop Anchor   
Addr : 0587:          05 11  : Call Sub 17   
Addr : 0589: CaseDone Label0009
Addr : 0589:             0C  : Casedone      
Addr : 058A: Label000A
651                            _getpid
Addr : 058A:             01  : Drop Anchor   
Addr : 058B:          05 12  : Call Sub 18   
Addr : 058D: CaseDone Label000A
Addr : 058D:             0C  : Casedone      
Addr : 058E: Label000B
653                            _kill
Addr : 058E:             01  : Drop Anchor   
Addr : 058F:          05 13  : Call Sub 19   
Addr : 0591: CaseDone Label000B
Addr : 0591:             0C  : Casedone      
Addr : 0592: Label000C
655                            _fstat
Addr : 0592:             01  : Drop Anchor   
Addr : 0593:          05 14  : Call Sub 20   
Addr : 0595: CaseDone Label000C
Addr : 0595:             0C  : Casedone      
Addr : 0596: Label000D
657                            _argvlen
Addr : 0596:             01  : Drop Anchor   
Addr : 0597:          05 15  : Call Sub 21   
Addr : 0599: CaseDone Label000D
Addr : 0599:             0C  : Casedone      
Addr : 059A: Label000E
659                            _argv
Addr : 059A:             01  : Drop Anchor   
Addr : 059B:          05 16  : Call Sub 22   
Addr : 059D: CaseDone Label000E
Addr : 059D:             0C  : Casedone      
Addr : 059E: Label000F
661                            _chdir
Addr : 059E:             01  : Drop Anchor   
Addr : 059F:          05 17  : Call Sub 23   
Addr : 05A1: CaseDone Label000F
Addr : 05A1:             0C  : Casedone      
Addr : 05A2: Label0010
663                            _stat
Addr : 05A2:             01  : Drop Anchor   
Addr : 05A3:          05 18  : Call Sub 24   
Addr : 05A5: CaseDone Label0010
Addr : 05A5:             0C  : Casedone      
Addr : 05A6: Label0011
665                            _chmod
Addr : 05A6:             01  : Drop Anchor   
Addr : 05A7:          05 19  : Call Sub 25   
Addr : 05A9: CaseDone Label0011
Addr : 05A9:             0C  : Casedone      
Addr : 05AA: Label0012
667                            _utime
Addr : 05AA:             01  : Drop Anchor   
Addr : 05AB:          05 1A  : Call Sub 26   
Addr : 05AD: CaseDone Label0012
Addr : 05AD:             0C  : Casedone      
Addr : 05AE: Label0013
669                            _time
Addr : 05AE:             01  : Drop Anchor   
Addr : 05AF:          05 1B  : Call Sub 27   
Addr : 05B1: CaseDone Label0013
Addr : 05B1:             0C  : Casedone      
Addr : 05B2: Label0002
670                        zog_mbox_command := 0
Addr : 05B2:             35  : Constant 1 $00000000
Addr : 05B3:          C9 20  : Memory Op Long VBASE + WRITE Address = 0020
Addr : 05B5:             32  : Return        
|===========================================================================|
Spin Block _exit with 0 Parameters and 0 Extra Stack Longs. Method 11
PRI _exit

Local Parameter DBASE:0000 - Result
|===========================================================================|
673                        ser.str(string("_exit ?"))
Addr : 05B6:             01  : Drop Anchor   
Addr : 05B7: PBASE Constant Address of Label0002
Addr : 05B7:       87 85 B0  : Memory Op Byte PBASE + ADDRESS Address = 05B0
Addr : 05BA:       06 21 0D  : Call Obj.Sub 33 13
Addr : 05BD: Label0003
Addr : 05BD: Label0004
Addr : 05BD: JMP Label0003
Addr : 05BD:          04 7E  : Jmp 05BD -2   
Addr : 05BF: Label0005
Addr : 05BF:             32  : Return        
Addr : 05C0: Label0002
Addr : 05C0: Data : 5F 65 78 69 74 20 3F 00  _exit ?.
Addr : 05C8: Data :                          
|===========================================================================|
Spin Block _open with 0 Parameters and 0 Extra Stack Longs. Method 12
PRI _open

Local Parameter DBASE:0000 - Result
|===========================================================================|
677                        ser.str(string("_open ?"))
Addr : 05C8:             01  : Drop Anchor   
Addr : 05C9: PBASE Constant Address of Label0002
Addr : 05C9:       87 85 C2  : Memory Op Byte PBASE + ADDRESS Address = 05C2
Addr : 05CC:       06 21 0D  : Call Obj.Sub 33 13
Addr : 05CF: Label0003
Addr : 05CF: Label0004
Addr : 05CF: JMP Label0003
Addr : 05CF:          04 7E  : Jmp 05CF -2   
Addr : 05D1: Label0005
Addr : 05D1:             32  : Return        
Addr : 05D2: Label0002
Addr : 05D2: Data : 5F 6F 70 65 6E 20 3F 00  _open ?.
Addr : 05DA: Data :                          
|===========================================================================|
Spin Block _close with 0 Parameters and 0 Extra Stack Longs. Method 13
PRI _close

Local Parameter DBASE:0000 - Result
|===========================================================================|
681                        ser.str(string("_close ?"))
Addr : 05DA:             01  : Drop Anchor   
Addr : 05DB: PBASE Constant Address of Label0002
Addr : 05DB:       87 85 D4  : Memory Op Byte PBASE + ADDRESS Address = 05D4
Addr : 05DE:       06 21 0D  : Call Obj.Sub 33 13
Addr : 05E1: Label0003
Addr : 05E1: Label0004
Addr : 05E1: JMP Label0003
Addr : 05E1:          04 7E  : Jmp 05E1 -2   
Addr : 05E3: Label0005
Addr : 05E3:             32  : Return        
Addr : 05E4: Label0002
Addr : 05E4: Data : 5F 63 6C 6F 73 65 20 3F  _close ?
Addr : 05EC: Data : 00                       .
|===========================================================================|
Spin Block _read with 0 Parameters and 3 Extra Stack Longs. Method 14
PRI _read | i, f, p

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - i
Local Variable  DBASE:0008 - f
Local Variable  DBASE:000C - p
|===========================================================================|
689                        f := @zpu_memory[long[framep + 16]]                   'Get buff ptr from ZPU stack
Addr : 05ED:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 05EF:          37 03  : Constant Mask Y=3 00000010 16
Addr : 05F1:             EC  : Math Op +     
Addr : 05F2:             C0  : Memory Op Long POP Address READ 
Addr : 05F3:       97 80 90  : Memory Op Byte PBASE + POP Index ADDRESS Address = 0090
Addr : 05F6:             69  : Variable Operation Local Offset - 2 Write
690                        p := f
Addr : 05F7:             68  : Variable Operation Local Offset - 2 Read
Addr : 05F8:             6D  : Variable Operation Local Offset - 3 Write
Addr : 05F9: Constant Address of Label0002
Addr : 05F9:       39 06 14  : Constant 2 Bytes - 06 14 - $00000614 1556
691                        case long[framep + 12]                                'Check file descriptor
Addr : 05FC:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 05FE:          38 0C  : Constant 1 Bytes - 0C - $0000000C 12
Addr : 0600:             EC  : Math Op +     
Addr : 0601:             C0  : Memory Op Long POP Address READ 
692                          STDIN_FILENO, STDERR_FILENO:                        'Console input?
Addr : 0602:             35  : Constant 1 $00000000
Addr : 0603: Case_Value Label0003
Addr : 0603:          0D 05  : Value Case Address = 060A 5
Addr : 0605:          37 00  : Constant Mask Y=0 00000002 2
Addr : 0607: Case_Value Label0003
Addr : 0607:          0D 01  : Value Case Address = 060A 1
Addr : 0609: CaseDone Label0003
Addr : 0609:             0C  : Casedone      
Addr : 060A: Label0003
693                            repeat i from 0 to long[framep + 20] - 1          'Input nbytes
Addr : 060A:             35  : Constant 1 $00000000
Addr : 060B:             65  : Variable Operation Local Offset - 1 Write
Addr : 060C: Label0004
694                              byte[p ^ %11] := ser.rx                         'XOR here is an endianess fix.
Addr : 060C:             00  : Drop Anchor Push 
Addr : 060D:       06 21 05  : Call Obj.Sub 33 5
Addr : 0610:             6C  : Variable Operation Local Offset - 3 Read
Addr : 0611:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 0613:             EB  : Math Op ^     
Addr : 0614:             81  : Memory Op Byte POP Address WRITE 
695                              p++
Addr : 0615:          6E 2E  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long
Addr : 0617: Label0005
693                            repeat i from 0 to long[framep + 20] - 1          'Input nbytes
Addr : 0617:             35  : Constant 1 $00000000
Addr : 0618:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 061A:          38 14  : Constant 1 Bytes - 14 - $00000014 20
Addr : 061C:             EC  : Math Op +     
Addr : 061D:             C0  : Memory Op Long POP Address READ 
Addr : 061E:             36  : Constant 2 $00000001
Addr : 061F:             ED  : Math Op -     
Addr : 0620: Repeat i Step Label0004
Addr : 0620:       66 02 69  : Variable Operation Local Offset - 1 Assign Repeat-Var loop Address= 060C -23
Addr : 0623: Label0006
Addr : 0623: CaseDone Label0003
Addr : 0623:             0C  : Casedone      
Addr : 0624: Label0002
699                        long[@zpu_memory[0]) := p - f                         'Return value via _mreg (aka R0) at ZPU address 0 !
Addr : 0624:             6C  : Variable Operation Local Offset - 3 Read
Addr : 0625:             68  : Variable Operation Local Offset - 2 Read
Addr : 0626:             ED  : Math Op -     
Addr : 0627:             35  : Constant 1 $00000000
Addr : 0628:       97 80 90  : Memory Op Byte PBASE + POP Index ADDRESS Address = 0090
Addr : 062B:             C1  : Memory Op Long POP Address WRITE 
Addr : 062C:             32  : Return        
|===========================================================================|
Spin Block _write with 0 Parameters and 3 Extra Stack Longs. Method 15
PRI _write | i, p, f

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - i
Local Variable  DBASE:0008 - p
Local Variable  DBASE:000C - f
|===========================================================================|
706                        f := @zpu_memory[long[framep + 16]]                   'Get buff ptr from ZPU stack
Addr : 062D:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 062F:          37 03  : Constant Mask Y=3 00000010 16
Addr : 0631:             EC  : Math Op +     
Addr : 0632:             C0  : Memory Op Long POP Address READ 
Addr : 0633:       97 80 90  : Memory Op Byte PBASE + POP Index ADDRESS Address = 0090
Addr : 0636:             6D  : Variable Operation Local Offset - 3 Write
707                        p := f
Addr : 0637:             6C  : Variable Operation Local Offset - 3 Read
Addr : 0638:             69  : Variable Operation Local Offset - 2 Write
Addr : 0639: Constant Address of Label0002
Addr : 0639:       39 06 54  : Constant 2 Bytes - 06 54 - $00000654 1620
708                        case long[framep + 12]                                'Check file descriptor
Addr : 063C:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 063E:          38 0C  : Constant 1 Bytes - 0C - $0000000C 12
Addr : 0640:             EC  : Math Op +     
Addr : 0641:             C0  : Memory Op Long POP Address READ 
709                          STDOUT_FILENO,STDERR_FILENO:                        'Console output?
Addr : 0642:             36  : Constant 2 $00000001
Addr : 0643: Case_Value Label0003
Addr : 0643:          0D 05  : Value Case Address = 064A 5
Addr : 0645:          37 00  : Constant Mask Y=0 00000002 2
Addr : 0647: Case_Value Label0003
Addr : 0647:          0D 01  : Value Case Address = 064A 1
Addr : 0649: CaseDone Label0003
Addr : 0649:             0C  : Casedone      
Addr : 064A: Label0003
710                            repeat i from 0 to long[framep + 20] - 1          'Output nbytes
Addr : 064A:             35  : Constant 1 $00000000
Addr : 064B:             65  : Variable Operation Local Offset - 1 Write
Addr : 064C: Label0004
711                              ser.tx(byte[p ^ %11])                           'XOR here is an endianess fix.
Addr : 064C:             01  : Drop Anchor   
Addr : 064D:             68  : Variable Operation Local Offset - 2 Read
Addr : 064E:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 0650:             EB  : Math Op ^     
Addr : 0651:             80  : Memory Op Byte POP Address READ 
Addr : 0652:       06 21 04  : Call Obj.Sub 33 4
712                              p++
Addr : 0655:          6A 2E  : Variable Operation Local Offset - 2 Assign VAR++ post inc Long
Addr : 0657: Label0005
710                            repeat i from 0 to long[framep + 20] - 1          'Output nbytes
Addr : 0657:             35  : Constant 1 $00000000
Addr : 0658:          C8 5C  : Memory Op Long VBASE + READ Address = 005C
Addr : 065A:          38 14  : Constant 1 Bytes - 14 - $00000014 20
Addr : 065C:             EC  : Math Op +     
Addr : 065D:             C0  : Memory Op Long POP Address READ 
Addr : 065E:             36  : Constant 2 $00000001
Addr : 065F:             ED  : Math Op -     
Addr : 0660: Repeat i Step Label0004
Addr : 0660:       66 02 69  : Variable Operation Local Offset - 1 Assign Repeat-Var loop Address= 064C -23
Addr : 0663: Label0006
Addr : 0663: CaseDone Label0003
Addr : 0663:             0C  : Casedone      
Addr : 0664: Label0002
716                        long[@zpu_memory[0]) := p - f                         'Return value via _mreg (aka R0) at ZPU address 0 !
Addr : 0664:             68  : Variable Operation Local Offset - 2 Read
Addr : 0665:             6C  : Variable Operation Local Offset - 3 Read
Addr : 0666:             ED  : Math Op -     
Addr : 0667:             35  : Constant 1 $00000000
Addr : 0668:       97 80 90  : Memory Op Byte PBASE + POP Index ADDRESS Address = 0090
Addr : 066B:             C1  : Memory Op Long POP Address WRITE 
Addr : 066C:             32  : Return        
|===========================================================================|
Spin Block _lseek with 0 Parameters and 0 Extra Stack Longs. Method 16
PRI _lseek

Local Parameter DBASE:0000 - Result
|===========================================================================|
719                        ser.str(string("_lseek ?"))
Addr : 066D:             01  : Drop Anchor   
Addr : 066E: PBASE Constant Address of Label0002
Addr : 066E:       87 86 67  : Memory Op Byte PBASE + ADDRESS Address = 0667
Addr : 0671:       06 21 0D  : Call Obj.Sub 33 13
Addr : 0674: Label0003
Addr : 0674: Label0004
Addr : 0674: JMP Label0003
Addr : 0674:          04 7E  : Jmp 0674 -2   
Addr : 0676: Label0005
Addr : 0676:             32  : Return        
Addr : 0677: Label0002
Addr : 0677: Data : 5F 6C 73 65 65 6B 20 3F  _lseek ?
Addr : 067F: Data : 00                       .
|===========================================================================|
Spin Block _unlink with 0 Parameters and 0 Extra Stack Longs. Method 17
PRI _unlink

Local Parameter DBASE:0000 - Result
|===========================================================================|
723                        ser.str(string("_unlink ?"))
Addr : 0680:             01  : Drop Anchor   
Addr : 0681: PBASE Constant Address of Label0002
Addr : 0681:       87 86 7A  : Memory Op Byte PBASE + ADDRESS Address = 067A
Addr : 0684:       06 21 0D  : Call Obj.Sub 33 13
Addr : 0687: Label0003
Addr : 0687: Label0004
Addr : 0687: JMP Label0003
Addr : 0687:          04 7E  : Jmp 0687 -2   
Addr : 0689: Label0005
Addr : 0689:             32  : Return        
Addr : 068A: Label0002
Addr : 068A: Data : 5F 75 6E 6C 69 6E 6B 20  _unlink 
Addr : 0692: Data : 3F 00                    ?.
|===========================================================================|
Spin Block _getpid with 0 Parameters and 0 Extra Stack Longs. Method 18
PRI _getpid

Local Parameter DBASE:0000 - Result
|===========================================================================|
727                        ser.str(string("_getpid ?"))
Addr : 0694:             01  : Drop Anchor   
Addr : 0695: PBASE Constant Address of Label0002
Addr : 0695:       87 86 8E  : Memory Op Byte PBASE + ADDRESS Address = 068E
Addr : 0698:       06 21 0D  : Call Obj.Sub 33 13
Addr : 069B: Label0003
Addr : 069B: Label0004
Addr : 069B: JMP Label0003
Addr : 069B:          04 7E  : Jmp 069B -2   
Addr : 069D: Label0005
Addr : 069D:             32  : Return        
Addr : 069E: Label0002
Addr : 069E: Data : 5F 67 65 74 70 69 64 20  _getpid 
Addr : 06A6: Data : 3F 00                    ?.
|===========================================================================|
Spin Block _kill with 0 Parameters and 0 Extra Stack Longs. Method 19
PRI _kill

Local Parameter DBASE:0000 - Result
|===========================================================================|
731                        ser.str(string("_kill ?"))
Addr : 06A8:             01  : Drop Anchor   
Addr : 06A9: PBASE Constant Address of Label0002
Addr : 06A9:       87 86 A2  : Memory Op Byte PBASE + ADDRESS Address = 06A2
Addr : 06AC:       06 21 0D  : Call Obj.Sub 33 13
Addr : 06AF: Label0003
Addr : 06AF: Label0004
Addr : 06AF: JMP Label0003
Addr : 06AF:          04 7E  : Jmp 06AF -2   
Addr : 06B1: Label0005
Addr : 06B1:             32  : Return        
Addr : 06B2: Label0002
Addr : 06B2: Data : 5F 6B 69 6C 6C 20 3F 00  _kill ?.
Addr : 06BA: Data :                          
|===========================================================================|
Spin Block _fstat with 0 Parameters and 0 Extra Stack Longs. Method 20
PRI _fstat

Local Parameter DBASE:0000 - Result
|===========================================================================|
735                        long[@zpu_memory[0]) := 0                             'Return value via _mreg (aka R0) at ZPU address 0 !
Addr : 06BA:             35  : Constant 1 $00000000
Addr : 06BB:             35  : Constant 1 $00000000
Addr : 06BC:       97 80 90  : Memory Op Byte PBASE + POP Index ADDRESS Address = 0090
Addr : 06BF:             C1  : Memory Op Long POP Address WRITE 
Addr : 06C0:             32  : Return        
|===========================================================================|
Spin Block _argvlen with 0 Parameters and 0 Extra Stack Longs. Method 21
PRI _argvlen

Local Parameter DBASE:0000 - Result
|===========================================================================|
738                        ser.str(string("_argvlen ?"))
Addr : 06C1:             01  : Drop Anchor   
Addr : 06C2: PBASE Constant Address of Label0002
Addr : 06C2:       87 86 BB  : Memory Op Byte PBASE + ADDRESS Address = 06BB
Addr : 06C5:       06 21 0D  : Call Obj.Sub 33 13
Addr : 06C8: Label0003
Addr : 06C8: Label0004
Addr : 06C8: JMP Label0003
Addr : 06C8:          04 7E  : Jmp 06C8 -2   
Addr : 06CA: Label0005
Addr : 06CA:             32  : Return        
Addr : 06CB: Label0002
Addr : 06CB: Data : 5F 61 72 67 76 6C 65 6E  _argvlen
Addr : 06D3: Data : 20 3F 00                  ?.
|===========================================================================|
Spin Block _argv with 0 Parameters and 0 Extra Stack Longs. Method 22
PRI _argv

Local Parameter DBASE:0000 - Result
|===========================================================================|
742                        ser.str(string("_argv ?"))
Addr : 06D6:             01  : Drop Anchor   
Addr : 06D7: PBASE Constant Address of Label0002
Addr : 06D7:       87 86 D0  : Memory Op Byte PBASE + ADDRESS Address = 06D0
Addr : 06DA:       06 21 0D  : Call Obj.Sub 33 13
Addr : 06DD: Label0003
Addr : 06DD: Label0004
Addr : 06DD: JMP Label0003
Addr : 06DD:          04 7E  : Jmp 06DD -2   
Addr : 06DF: Label0005
Addr : 06DF:             32  : Return        
Addr : 06E0: Label0002
Addr : 06E0: Data : 5F 61 72 67 76 20 3F 00  _argv ?.
Addr : 06E8: Data :                          
|===========================================================================|
Spin Block _chdir with 0 Parameters and 0 Extra Stack Longs. Method 23
PRI _chdir

Local Parameter DBASE:0000 - Result
|===========================================================================|
746                        ser.str(string("_chdir ?"))
Addr : 06E8:             01  : Drop Anchor   
Addr : 06E9: PBASE Constant Address of Label0002
Addr : 06E9:       87 86 E2  : Memory Op Byte PBASE + ADDRESS Address = 06E2
Addr : 06EC:       06 21 0D  : Call Obj.Sub 33 13
Addr : 06EF: Label0003
Addr : 06EF: Label0004
Addr : 06EF: JMP Label0003
Addr : 06EF:          04 7E  : Jmp 06EF -2   
Addr : 06F1: Label0005
Addr : 06F1:             32  : Return        
Addr : 06F2: Label0002
Addr : 06F2: Data : 5F 63 68 64 69 72 20 3F  _chdir ?
Addr : 06FA: Data : 00                       .
|===========================================================================|
Spin Block _stat with 0 Parameters and 0 Extra Stack Longs. Method 24
PRI _stat

Local Parameter DBASE:0000 - Result
|===========================================================================|
750                        ser.str(string("_stat ?"))
Addr : 06FB:             01  : Drop Anchor   
Addr : 06FC: PBASE Constant Address of Label0002
Addr : 06FC:       87 86 F5  : Memory Op Byte PBASE + ADDRESS Address = 06F5
Addr : 06FF:       06 21 0D  : Call Obj.Sub 33 13
Addr : 0702: Label0003
Addr : 0702: Label0004
Addr : 0702: JMP Label0003
Addr : 0702:          04 7E  : Jmp 0702 -2   
Addr : 0704: Label0005
Addr : 0704:             32  : Return        
Addr : 0705: Label0002
Addr : 0705: Data : 5F 73 74 61 74 20 3F 00  _stat ?.
Addr : 070D: Data :                          
|===========================================================================|
Spin Block _chmod with 0 Parameters and 0 Extra Stack Longs. Method 25
PRI _chmod

Local Parameter DBASE:0000 - Result
|===========================================================================|
754                        ser.str(string("_chmod ?"))
Addr : 070D:             01  : Drop Anchor   
Addr : 070E: PBASE Constant Address of Label0002
Addr : 070E:       87 87 07  : Memory Op Byte PBASE + ADDRESS Address = 0707
Addr : 0711:       06 21 0D  : Call Obj.Sub 33 13
Addr : 0714: Label0003
Addr : 0714: Label0004
Addr : 0714: JMP Label0003
Addr : 0714:          04 7E  : Jmp 0714 -2   
Addr : 0716: Label0005
Addr : 0716:             32  : Return        
Addr : 0717: Label0002
Addr : 0717: Data : 5F 63 68 6D 6F 64 20 3F  _chmod ?
Addr : 071F: Data : 00                       .
|===========================================================================|
Spin Block _utime with 0 Parameters and 0 Extra Stack Longs. Method 26
PRI _utime

Local Parameter DBASE:0000 - Result
|===========================================================================|
758                        ser.str(string("_utime ?"))
Addr : 0720:             01  : Drop Anchor   
Addr : 0721: PBASE Constant Address of Label0002
Addr : 0721:       87 87 1A  : Memory Op Byte PBASE + ADDRESS Address = 071A
Addr : 0724:       06 21 0D  : Call Obj.Sub 33 13
Addr : 0727: Label0003
Addr : 0727: Label0004
Addr : 0727: JMP Label0003
Addr : 0727:          04 7E  : Jmp 0727 -2   
Addr : 0729: Label0005
Addr : 0729:             32  : Return        
Addr : 072A: Label0002
Addr : 072A: Data : 5F 75 74 69 6D 65 20 3F  _utime ?
Addr : 0732: Data : 00                       .
|===========================================================================|
Spin Block _time with 0 Parameters and 0 Extra Stack Longs. Method 27
PRI _time

Local Parameter DBASE:0000 - Result
|===========================================================================|
762                        ser.str(string("_time ?"))
Addr : 0733:             01  : Drop Anchor   
Addr : 0734: PBASE Constant Address of Label0002
Addr : 0734:       87 87 2D  : Memory Op Byte PBASE + ADDRESS Address = 072D
Addr : 0737:       06 21 0D  : Call Obj.Sub 33 13
Addr : 073A: Label0003
Addr : 073A: Label0004
Addr : 073A: JMP Label0003
Addr : 073A:          04 7E  : Jmp 073A -2   
Addr : 073C: Label0005
Addr : 073C:             32  : Return        
Addr : 073D: Label0002
Addr : 073D: Data : 5F 74 69 6D 65 20 3F 00  _time ?.
Addr : 0745: Data :                          
|===========================================================================|
Spin Block print_regs with 0 Parameters and 3 Extra Stack Longs. Method 28
PRI print_regs | i, p, op

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - i
Local Variable  DBASE:0008 - p
Local Variable  DBASE:000C - op
|===========================================================================|
767                        ser.str(string("0X"))
Addr : 0745:             01  : Drop Anchor   
Addr : 0746: PBASE Constant Address of Label0002
Addr : 0746:       87 87 D0  : Memory Op Byte PBASE + ADDRESS Address = 07D0
Addr : 0749:       06 21 0D  : Call Obj.Sub 33 13
768                        ser.hex(zog_mbox_pc, 7)
Addr : 074C:             01  : Drop Anchor   
Addr : 074D:          C8 2C  : Memory Op Long VBASE + READ Address = 002C
Addr : 074F:          37 22  : Constant Mask Y=34 Decrement 00000007 7
Addr : 0751:       06 21 15  : Call Obj.Sub 33 21
769                        ser.tx($20)
Addr : 0754:             01  : Drop Anchor   
Addr : 0755:          37 04  : Constant Mask Y=4 00000020 32
Addr : 0757:       06 21 04  : Call Obj.Sub 33 4
770                        ser.str(string("0X"))
Addr : 075A:             01  : Drop Anchor   
Addr : 075B: PBASE Constant Address of Label0003
Addr : 075B:       87 87 D3  : Memory Op Byte PBASE + ADDRESS Address = 07D3
Addr : 075E:       06 21 0D  : Call Obj.Sub 33 13
775                        op := vm.rdvbyte(zog_mbox_pc ^ %11)                   'XOR here is an endianess fix.
Addr : 0761:             00  : Drop Anchor Push 
Addr : 0762:          C8 2C  : Memory Op Long VBASE + READ Address = 002C
Addr : 0764:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 0766:             EB  : Math Op ^     
Addr : 0767:       06 23 02  : Call Obj.Sub 35 2
Addr : 076A:             6D  : Variable Operation Local Offset - 3 Write
780                        ser.hex(op, 2)
Addr : 076B:             01  : Drop Anchor   
Addr : 076C:             6C  : Variable Operation Local Offset - 3 Read
Addr : 076D:          37 00  : Constant Mask Y=0 00000002 2
Addr : 076F:       06 21 15  : Call Obj.Sub 33 21
781                        ser.tx($20)
Addr : 0772:             01  : Drop Anchor   
Addr : 0773:          37 04  : Constant Mask Y=4 00000020 32
Addr : 0775:       06 21 04  : Call Obj.Sub 33 4
782                        ser.str(string("0X"))
Addr : 0778:             01  : Drop Anchor   
Addr : 0779: PBASE Constant Address of Label0004
Addr : 0779:       87 87 D6  : Memory Op Byte PBASE + ADDRESS Address = 07D6
Addr : 077C:       06 21 0D  : Call Obj.Sub 33 13
783                        ser.hex(zog_mbox_sp, 8)
Addr : 077F:             01  : Drop Anchor   
Addr : 0780:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 0782:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0784:       06 21 15  : Call Obj.Sub 33 21
784                        ser.tx($20)
Addr : 0787:             01  : Drop Anchor   
Addr : 0788:          37 04  : Constant Mask Y=4 00000020 32
Addr : 078A:       06 21 04  : Call Obj.Sub 33 4
785                        ser.str(string("0X"))
Addr : 078D:             01  : Drop Anchor   
Addr : 078E: PBASE Constant Address of Label0005
Addr : 078E:       87 87 D9  : Memory Op Byte PBASE + ADDRESS Address = 07D9
Addr : 0791:       06 21 0D  : Call Obj.Sub 33 13
786                        ser.hex(zog_mbox_tos, 8)
Addr : 0794:             01  : Drop Anchor   
Addr : 0795:          C8 34  : Memory Op Long VBASE + READ Address = 0034
Addr : 0797:          37 02  : Constant Mask Y=2 00000008 8
Addr : 0799:       06 21 15  : Call Obj.Sub 33 21
787                        crlf
Addr : 079C:             01  : Drop Anchor   
Addr : 079D:          05 1D  : Call Sub 29   
Addr : 079F: Constant Address of Label0006
Addr : 079F:       39 07 CF  : Constant 2 Bytes - 07 CF - $000007CF 1999
789                        case op
Addr : 07A2:             6C  : Variable Operation Local Offset - 3 Read
790                          $00:
Addr : 07A3:             35  : Constant 1 $00000000
Addr : 07A4: Case_Value Label0007
Addr : 07A4:          0D 18  : Value Case Address = 07BE 24
793                          $01,$03,$0E,$0F:
Addr : 07A6:             36  : Constant 2 $00000001
Addr : 07A7: Case_Value Label0009
Addr : 07A7:          0D 20  : Value Case Address = 07C9 32
Addr : 07A9:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 07AB: Case_Value Label0009
Addr : 07AB:          0D 1C  : Value Case Address = 07C9 28
Addr : 07AD:          38 0E  : Constant 1 Bytes - 0E - $0000000E 14
Addr : 07AF: Case_Value Label0009
Addr : 07AF:          0D 18  : Value Case Address = 07C9 24
Addr : 07B1:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 07B3: Case_Value Label0009
Addr : 07B3:          0D 14  : Value Case Address = 07C9 20
796                          $20,$21:
Addr : 07B5:          37 04  : Constant Mask Y=4 00000020 32
Addr : 07B7: Case_Value Label000B
Addr : 07B7:          0D 1B  : Value Case Address = 07D4 27
Addr : 07B9:          38 21  : Constant 1 Bytes - 21 - $00000021 33
Addr : 07BB: Case_Value Label000B
Addr : 07BB:          0D 17  : Value Case Address = 07D4 23
Addr : 07BD: CaseDone Label000B
Addr : 07BD:             0C  : Casedone      
Addr : 07BE: Label0007
791                            ser.str(string("BREAKPOINT"))
Addr : 07BE:             01  : Drop Anchor   
Addr : 07BF: PBASE Constant Address of Label0008
Addr : 07BF:       87 87 DC  : Memory Op Byte PBASE + ADDRESS Address = 07DC
Addr : 07C2:       06 21 0D  : Call Obj.Sub 33 13
792                            crlf
Addr : 07C5:             01  : Drop Anchor   
Addr : 07C6:          05 1D  : Call Sub 29   
Addr : 07C8: CaseDone Label0007
Addr : 07C8:             0C  : Casedone      
Addr : 07C9: Label0009
794                            ser.str(string("ILLEGAL OP"))
Addr : 07C9:             01  : Drop Anchor   
Addr : 07CA: PBASE Constant Address of Label000A
Addr : 07CA:       87 87 E7  : Memory Op Byte PBASE + ADDRESS Address = 07E7
Addr : 07CD:       06 21 0D  : Call Obj.Sub 33 13
795                            crlf
Addr : 07D0:             01  : Drop Anchor   
Addr : 07D1:          05 1D  : Call Sub 29   
Addr : 07D3: CaseDone Label0009
Addr : 07D3:             0C  : Casedone      
Addr : 07D4: Label000B
797                            ser.str(string("NOT_IMPLEMENTED"))
Addr : 07D4:             01  : Drop Anchor   
Addr : 07D5: PBASE Constant Address of Label000C
Addr : 07D5:       87 87 F2  : Memory Op Byte PBASE + ADDRESS Address = 07F2
Addr : 07D8:       06 21 0D  : Call Obj.Sub 33 13
798                            crlf
Addr : 07DB:             01  : Drop Anchor   
Addr : 07DC:          05 1D  : Call Sub 29   
Addr : 07DE: CaseDone Label000B
Addr : 07DE:             0C  : Casedone      
Addr : 07DF: Label0006
Addr : 07DF:             32  : Return        
Addr : 07E0: Label0002
Addr : 07E0: Data : 30 58 00                 0X.
Addr : 07E3: Label0003
Addr : 07E3: Data : 30 58 00                 0X.
Addr : 07E6: Label0004
Addr : 07E6: Data : 30 58 00                 0X.
Addr : 07E9: Label0005
Addr : 07E9: Data : 30 58 00                 0X.
Addr : 07EC: Label0008
Addr : 07EC: Data : 42 52 45 41 4B 50 4F 49  BREAKPOI
Addr : 07F4: Data : 4E 54 00                 NT.
Addr : 07F7: Label000A
Addr : 07F7: Data : 49 4C 4C 45 47 41 4C 20  ILLEGAL 
Addr : 07FF: Data : 4F 50 00                 OP.
Addr : 0802: Label000C
Addr : 0802: Data : 4E 4F 54 5F 49 4D 50 4C  NOT_IMPL
Addr : 080A: Data : 45 4D 45 4E 54 45 44 00  EMENTED.
Addr : 0812: Data :                          
|===========================================================================|
Spin Block crlf with 0 Parameters and 0 Extra Stack Longs. Method 29
PRI crlf

Local Parameter DBASE:0000 - Result
|===========================================================================|
809                        ser.tx(13)
Addr : 0812:             01  : Drop Anchor   
Addr : 0813:          38 0D  : Constant 1 Bytes - 0D - $0000000D 13
Addr : 0815:       06 21 04  : Call Obj.Sub 33 4
810                        ser.tx(10)
Addr : 0818:             01  : Drop Anchor   
Addr : 0819:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 081B:       06 21 04  : Call Obj.Sub 33 4
Addr : 081E:             32  : Return        
|===========================================================================|
Spin Block CheckError with 1 Parameters and 0 Extra Stack Longs. Method 30
PRI CheckError(r)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - r
|===========================================================================|
813                        if r < 0
Addr : 081F:             64  : Variable Operation Local Offset - 1 Read
Addr : 0820:             35  : Constant 1 $00000000
Addr : 0821:             F9  : Math Op <     
Addr : 0822: JZ Label0002
Addr : 0822:          0A 1A  : jz Address = 083E 26
814                          ser.str(string("Error: "))
Addr : 0824:             01  : Drop Anchor   
Addr : 0825: PBASE Constant Address of Label0004
Addr : 0825:       87 88 2F  : Memory Op Byte PBASE + ADDRESS Address = 082F
Addr : 0828:       06 21 0D  : Call Obj.Sub 33 13
815                          ser.hex(r,2)
Addr : 082B:             01  : Drop Anchor   
Addr : 082C:             64  : Variable Operation Local Offset - 1 Read
Addr : 082D:          37 00  : Constant Mask Y=0 00000002 2
Addr : 082F:       06 21 15  : Call Obj.Sub 33 21
816                          ser.str(string(" HALTED."))
Addr : 0832:             01  : Drop Anchor   
Addr : 0833: PBASE Constant Address of Label0005
Addr : 0833:       87 88 37  : Memory Op Byte PBASE + ADDRESS Address = 0837
Addr : 0836:       06 21 0D  : Call Obj.Sub 33 13
817                          crlf
Addr : 0839:             01  : Drop Anchor   
Addr : 083A:          05 1D  : Call Sub 29   
Addr : 083C: Label0006
Addr : 083C: Label0007
Addr : 083C: JMP Label0006
Addr : 083C:          04 7E  : Jmp 083C -2   
Addr : 083E: Label0008
Addr : 083E: Label0002
Addr : 083E: Label0003
Addr : 083E:             32  : Return        
Addr : 083F: Label0004
Addr : 083F: Data : 45 72 72 6F 72 3A 20 00  Error: .
Addr : 0847: Data :                          
Addr : 0847: Label0005
Addr : 0847: Data : 20 48 41 4C 54 45 44 2E   HALTED.
Addr : 084F: Data : 00                       .
|===========================================================================|
Object userdefs.spin
Object Base is 0850
|===========================================================================|
Object Constants
|===========================================================================|
|===========================================================================|
Spin Block nopub with 0 Parameters and 0 Extra Stack Longs. Method 1
pub nopub '' not used

Local Parameter DBASE:0000 - Result
|===========================================================================|
Addr : 0858:             32  : Return        
|===========================================================================|
Object zog_1_5_lsmod.spin
Object Base is 085C
|===========================================================================|
Object Constants
|===========================================================================|
|===========================================================================|
VBASE Global Variables
|===========================================================================|
VBASE : 0000 LONG Size 0004 Variable cog
|===========================================================================|
Object DAT Blocks
|===========================================================================|
0870(0000)             |                         org     0
0870(0000) 6B 01 7C 5C | enter                   jmp     #init
0874(0001) 8D 2B FF 5C | zpu_breakpoint          call    #break
0878(0002) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
087C(0003) 73 E7 BE 80 | zpu_addsp_0             add     tos, tos                'Special case for offset = 0
0880(0004) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0884(0005) 0F D6 FE 60 | zpu_addsp               and     address, #$0F
0888(0006) 02 D6 FE 2C |                         shl     address, #2
088C(0007) 72 D7 BE 80 |                         add     address, sp
0890(0008) F2 F6 FD 5C |                         call    #read_long
0894(0009) 75 E7 BE 80 |                         add     tos, data
0898(000A) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
089C(000B) E0 D0 FD 5C | zpu_loadsp_tos          call    #push_tos
08A0(000C) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
08A4(000D)             | zpu_loadsp_hi           ' this will fall through if we're saving space
08A4(000D) 0F D6 FE 60 |                         and     address, #$0F           'bit 4 was 1...Trust me, you need this.
08A8(000E) 02 D6 FE 2C |                         shl     address, #2
08AC(000F) 72 D7 BE 80 |                         add     address, sp
08B0(0010) E0 D0 FD 5C |                         call    #push_tos
08B4(0011) F2 F6 FD 5C |                         call    #read_long
08B8(0012) 75 E7 BE A0 |                         mov     tos, data
08BC(0013) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
08C0(0014) 1F D6 FE 60 | zpu_loadsp              and     address, #$1F
08C4(0015) 10 D6 FE 6C |                         xor     address, #$10           'Trust me, you need this.
08C8(0016) 02 D6 FE 2C |                         shl     address, #2
08CC(0017) 72 D7 BE 80 |                         add     address, sp
08D0(0018) E0 D0 FD 5C |                         call    #push_tos
08D4(0019) F2 F6 FD 5C |                         call    #read_long
08D8(001A) 75 E7 BE A0 |                         mov     tos, data
08DC(001B) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
08E0(001C) E9 E2 FD 5C | zpu_storesp_tos         call    #pop
08E4(001D) 75 E7 BE A0 |                         mov     tos, data
08E8(001E) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
08EC(001F)             | zpu_storesp_hi          ' this will fall through if we're saving space
08EC(001F) 0F D6 FE 60 |                         and     address, #$0F           'bit 4 was 1...Trust me, you need this.
08F0(0020) 02 D6 FE 2C |                         shl     address, #2
08F4(0021) 72 D7 BE 80 |                         add     address, sp
08F8(0022) 73 EB BE A0 |                         mov     data, tos
08FC(0023) FC 0A FE 5C |                         call    #write_long
0900(0024) E9 E2 FD 5C |                         call    #pop
0904(0025) 75 E7 BE A0 |                         mov     tos, data
0908(0026) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
090C(0027) 1F D6 FE 60 | zpu_storesp             and     address, #$1F
0910(0028) 10 D6 FE 6C |                         xor     address, #$10           'Trust me, you need this.
0914(0029) 02 D6 FE 2C |                         shl     address, #2
0918(002A) 72 D7 BE 80 |                         add     address, sp
091C(002B) 73 EB BE A0 |                         mov     data, tos
0920(002C) FC 0A FE 5C |                         call    #write_long
0924(002D) E9 E2 FD 5C |                         call    #pop
0928(002E) 75 E7 BE A0 |                         mov     tos, data
092C(002F) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0930(0030) 73 ED BE A0 | zpu_config              mov     cpu, tos
0934(0031) E9 E2 FD 5C |                         call    #pop
0938(0032) 75 E7 BE A0 |                         mov     tos, data
093C(0033) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0940(0034) E0 D0 FD 5C | zpu_pushpc              call    #push_tos
0944(0035) 70 E7 BE A0 |                         mov     tos, pc
0948(0036) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
094C(0037) E9 E2 FD 5C | zpu_or                  call    #pop
0950(0038) 75 E7 BE 68 |                         or      tos, data
0954(0039) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0958(003A) B5 E7 BE 6C | zpu_not                 xor     tos, minus_one
095C(003B) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0960(003C) 73 D7 BE A0 | zpu_load                mov     address, tos
0964(003D) F2 F6 FD 5C |                         call    #read_long
0968(003E) 75 E7 BE A0 |                         mov     tos, data
096C(003F) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0970(0040) 02 E6 FE 2C | zpu_pushspadd           shl     tos, #2
0974(0041) 72 E7 BE 80 |                         add     tos, sp
0978(0042) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
097C(0043) E9 E2 FD 5C | zpu_store               call    #pop
0980(0044) 73 D7 BE A0 |                         mov     address, tos
0984(0045) FC 0A FE 5C |                         call    #write_long
0988(0046) E9 E2 FD 5C |                         call    #pop
098C(0047) 75 E7 BE A0 |                         mov     tos, data
0990(0048) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0994(0049) 73 E1 BE A0 | zpu_poppc               mov     pc, tos
0998(004A) E9 E2 FD 5C |                         call    #pop
099C(004B) 75 E7 BE A0 |                         mov     tos, data
09A0(004C) 5C 01 7C 5C |                         jmp     #done
09A4(004D) 73 E1 BE 80 | zpu_poppcrel            add     pc, tos
09A8(004E) E9 E2 FD 5C |                         call    #pop
09AC(004F) 75 E7 BE A0 |                         mov     tos, data
09B0(0050) 5C 01 7C 5C |                         jmp     #done
09B4(0051) 20 E6 FE 3C | zpu_flip                rev     tos, #32
09B8(0052) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
09BC(0053) E9 E2 FD 5C | zpu_add                 call    #pop
09C0(0054) 75 E7 BE 80 |                         add     tos, data
09C4(0055) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
09C8(0056) E9 E2 FD 5C | zpu_sub                 call    #pop
09CC(0057) 73 EB BE 84 |                         sub     data, tos
09D0(0058) 75 E7 BE A0 |                         mov     tos, data
09D4(0059) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
09D8(005A) E0 D0 FD 5C | zpu_pushsp              call    #push_tos
09DC(005B) 72 E7 BE A0 |                         mov     tos, sp
09E0(005C) 04 E6 FE 80 |                         add     tos, #4
09E4(005D) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
09E8(005E) 73 E5 BE A0 | zpu_popsp               mov     sp, tos
09EC(005F) 72 D7 BE A0 |                         mov     address, sp
09F0(0060) F2 F6 FD 5C |                         call    #read_long
09F4(0061) 75 E7 BE A0 |                         mov     tos, data
09F8(0062) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
09FC(0063) 5B 01 7C 5C | zpu_nop                 jmp     #done_and_inc_pc
0A00(0064) E9 E2 FD 5C | zpu_and                 call    #pop
0A04(0065) 75 E7 BE 60 |                         and     tos, data
0A08(0066) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0A0C(0067) E9 E2 FD 5C | zpu_xor                 call    #pop
0A10(0068) 75 E7 BE 6C |                         xor     tos, data
0A14(0069) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0A18(006A)             | zpu_loadb
0A18(006A) 73 13 BF A0 |                         mov     addr, tos
0A1C(006B) 03 12 FF 6C |                         xor     addr, #%11              'XOR here is an endianess fix.
0A20(006C) 09 12 FF 2C |                         shl     addr, #9
0A24(006D) 82 12 FF 50 |                         movs    addr, #READVMB
0A28(006E) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0A2C(006F) 8A EB BE 0A | :waitres                rdlong  data, mboxcmd wz
0A30(0070) 6F 00 54 5C |               if_nz     jmp     #:waitres
0A34(0071) 8B E7 BE 00 |                         rdbyte  tos, mboxdat
0A38(0072) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0A3C(0073) E9 E2 FD 5C | zpu_storeb              call    #pop
0A40(0074) 8B EB 3E 00 |                         wrbyte  data, mboxdat
0A44(0075) 73 13 BF A0 |                         mov     addr, tos
0A48(0076) 03 12 FF 6C |                         xor     addr, #%11              'XOR here is an endianess fix.
0A4C(0077) 09 12 FF 2C |                         shl     addr, #9
0A50(0078) 85 12 FF 50 |                         movs    addr, #WRITEVMB
0A54(0079) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0A58(007A) 8A EB BE 0A | :waitdone               rdlong  data, mboxcmd wz
0A5C(007B) 7A 00 54 5C |                   if_nz jmp     #:waitdone
0A60(007C) E9 E2 FD 5C |                         call    #pop
0A64(007D) 75 E7 BE A0 |                         mov     tos, data
0A68(007E) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0A6C(007F) 73 D7 BE A0 | zpu_loadh               mov     address, tos
0A70(0080) 06 1D FE 5C |                         call    #read_word
0A74(0081) 75 E7 BE A0 |                         mov     tos, data
0A78(0082) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0A7C(0083) E9 E2 FD 5C | zpu_storeh              call    #pop
0A80(0084) 73 D7 BE A0 |                         mov     address, tos
0A84(0085) 0F 2F FE 5C |                         call    #write_word
0A88(0086) E9 E2 FD 5C |                         call    #pop
0A8C(0087) 75 E7 BE A0 |                         mov     tos, data
0A90(0088) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0A94(0089) E9 E2 FD 5C | zpu_lessthan            call    #pop
0A98(008A) 75 E7 3E C3 |                         cmps    tos, data wz,wc
0A9C(008B) 00 E6 FE A0 |                         mov     tos, #0
0AA0(008C) 01 E6 F2 A0 |               if_b      mov     tos, #1
0AA4(008D) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0AA8(008E) E9 E2 FD 5C | zpu_lessthanorequal     call    #pop
0AAC(008F) 75 E7 3E C3 |                         cmps    tos, data wz,wc
0AB0(0090) 00 E6 FE A0 |                         mov     tos, #0
0AB4(0091) 01 E6 FA A0 |               if_be     mov     tos, #1
0AB8(0092) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0ABC(0093) E9 E2 FD 5C | zpu_ulessthan           call    #pop
0AC0(0094) 75 E7 3E 87 |                         cmp     tos, data wz, wc
0AC4(0095) 00 E6 FE A0 |                         mov     tos, #0
0AC8(0096) 01 E6 F2 A0 |               if_b      mov     tos, #1
0ACC(0097) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0AD0(0098) E9 E2 FD 5C | zpu_ulessthanorequal    call    #pop
0AD4(0099) 75 E7 3E 87 |                         cmp     tos, data wz, wc
0AD8(009A) 00 E6 FE A0 |                         mov     tos, #0
0ADC(009B) 01 E6 FA A0 |               if_be     mov     tos, #1
0AE0(009C) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0AE4(009D) 10 E6 FE 20 | zpu_swap                ror     tos, #16
0AE8(009E) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0AEC(009F) E9 E2 FD 5C | zpu_mult16x16           call    #pop
0AF0(00A0) B7 EB BE 60 |                         and     data, word_mask
0AF4(00A1) B7 E7 BE 60 |                         and     tos, word_mask
0AF8(00A2) 33 01 7C 5C |                         jmp     #fast_mul
0AFC(00A3) E9 E2 FD 5C | zpu_eqbranch            call    #pop
0B00(00A4) 73 E1 AA 80 |               if_z      add     pc, tos
0B04(00A5) 01 E0 D6 80 |               if_nz     add     pc, #1
0B08(00A6) E9 E2 FD 5C |                         call    #pop
0B0C(00A7) 75 E7 BE A0 |                         mov     tos, data
0B10(00A8) 5C 01 7C 5C |                         jmp     #done
0B14(00A9) E9 E2 FD 5C | zpu_neqbranch           call    #pop
0B18(00AA) 73 E1 96 80 |               if_nz     add     pc, tos
0B1C(00AB) 01 E0 EA 80 |               if_z      add     pc, #1
0B20(00AC) E9 E2 FD 5C |                         call    #pop
0B24(00AD) 75 E7 BE A0 |                         mov     tos, data
0B28(00AE) 5C 01 7C 5C |                         jmp     #done
0B2C(00AF) E9 E2 FD 5C | zpu_mult                call    #pop
0B30(00B0) 33 01 7C 5C |                         jmp     #fast_mul
0B34(00B1) E9 E2 FD 5C | zpu_div                 call    #pop            ' pop sets z for me
0B38(00B2) DE 00 68 5C |               if_z      jmp     #div_zero_error
0B3C(00B3) 00 EE FE A0 |                         mov     div_flags, #SPIN_DIV_OP
0B40(00B4) 40 01 7C 5C |                         jmp     #fast_div
0B44(00B5) E9 E2 FD 5C | zpu_mod                 call    #pop            ' pop sets z for me
0B48(00B6) DE 00 68 5C |               if_z      jmp     #div_zero_error
0B4C(00B7) 01 EE FE A0 |                         mov     div_flags, #SPIN_REM_OP
0B50(00B8) 40 01 7C 5C |                         jmp     #fast_div
0B54(00B9) E9 E2 FD 5C | zpu_lshiftright         call    #pop
0B58(00BA) 3F E6 FE 60 |                         and     tos, #$3F
0B5C(00BB) 73 EB BE 28 |                         shr     data, tos
0B60(00BC) 75 E7 BE A0 |                         mov     tos, data
0B64(00BD) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0B68(00BE) E9 E2 FD 5C | zpu_ashiftleft          call    #pop
0B6C(00BF) 3F E6 FE 60 |                         and     tos, #$3F
0B70(00C0) 73 EB BE 2C |                         shl     data, tos
0B74(00C1) 75 E7 BE A0 |                         mov     tos, data
0B78(00C2) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0B7C(00C3) E9 E2 FD 5C | zpu_ashiftright         call    #pop
0B80(00C4) 3F E6 FE 60 |                         and     tos, #$3F
0B84(00C5) 73 EB BE 38 |                         sar     data, tos
0B88(00C6) 75 E7 BE A0 |                         mov     tos, data
0B8C(00C7) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0B90(00C8) 73 DF BE A0 | zpu_call                mov     temp, tos
0B94(00C9) 70 E7 BE A0 |                         mov     tos, pc
0B98(00CA) 01 E6 FE 80 |                         add     tos, #1
0B9C(00CB) 6F E1 BE A0 |                         mov     pc, temp
0BA0(00CC) 5C 01 7C 5C |                         jmp     #done
0BA4(00CD) 73 DF BE A0 | zpu_callpcrel           mov     temp, tos
0BA8(00CE) 70 E7 BE A0 |                         mov     tos, pc
0BAC(00CF) 01 E6 FE 80 |                         add     tos, #1
0BB0(00D0) 6F E1 BE 80 |                         add     pc, temp
0BB4(00D1) 5C 01 7C 5C |                         jmp     #done
0BB8(00D2) E9 E2 FD 5C | zpu_eq                  call    #pop
0BBC(00D3) 75 E7 3E 86 |                         cmp     tos, data wz
0BC0(00D4) 01 E6 EA A0 |               if_z      mov     tos, #1
0BC4(00D5) 00 E6 D6 A0 |               if_nz     mov     tos, #0
0BC8(00D6) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0BCC(00D7) E9 E2 FD 5C | zpu_neq                 call    #pop
0BD0(00D8) 75 E7 BE 86 |                         sub     tos, data wz
0BD4(00D9) 01 E6 D6 A0 |               if_nz     mov     tos, #1
0BD8(00DA) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0BDC(00DB) 73 E7 BE A4 | zpu_neg                 neg     tos, tos
0BE0(00DC) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0BE4(00DD) 96 01 7C 5C | zpu_syscall             jmp     #syscall
0BE8(00DE)             | not_implemented
0BE8(00DE)             | zpu_illegal
0BE8(00DE)             | div_zero_error
0BE8(00DE) 8D 2B FF 5C |                         call    #break
0BEC(00DF) 5C 01 7C 5C |                         jmp     #done
0BF0(00E0)             |                         fit $FF                         'Opcode handlers must fit in 256 LONGS
0BF0(00E0)             | There are 31 ($01F) Longs left in the cog
0BF0(00E0)             | push_tos
0BF0(00E0) 72 13 BF A0 |                         mov       addr, sp
0BF4(00E1) 8B E7 3E 08 |                         wrlong    tos, mboxdat
0BF8(00E2) 09 12 FF 2C |                         shl       addr, #9
0BFC(00E3) 87 12 FF 50 |                         movs      addr, #WRITEVML
0C00(00E4) 8A 13 3F 08 |                         wrlong    addr, mboxcmd
0C04(00E5) 8A 13 BF 0A | :waitdone               rdlong    addr, mboxcmd wz
0C08(00E6) E5 00 54 5C |                   if_nz jmp       #:waitdone
0C0C(00E7) 04 E4 FE 84 |                         sub     sp, #4
0C10(00E8) 00 00 7C 5C | push_tos_ret            ret
0C14(00E9) 04 E4 FE 80 | pop                     add     sp, #4
0C18(00EA) 72 13 BF A0 |                         mov     addr, sp
0C1C(00EB) 09 12 FF 2C |                         shl     addr, #9
0C20(00EC) 84 12 FF 50 |                         movs    addr, #READVML
0C24(00ED) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0C28(00EE) 8A EB BE 0A | :waitres                rdlong  data, mboxcmd wz
0C2C(00EF) EE 00 54 5C |               if_nz     jmp     #:waitres
0C30(00F0) 8B EB BE 0A |                         rdlong  data, mboxdat wz
0C34(00F1) 00 00 7C 5C | pop_ret                 ret
0C38(00F2) B7 D7 3E 85 | read_long               cmp     address, word_mask wc   'FIXME this only allows 64K RAM - FIXED allows any
0C3C(00F3) 18 01 4C 5C |               if_nc     jmp     #in_long
0C40(00F4) 6B 13 BF A0 |                         mov     addr, address
0C44(00F5) 09 12 FF 2C |                         shl     addr, #9
0C48(00F6) 84 12 FF 50 |                         movs    addr, #READVML
0C4C(00F7) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0C50(00F8) 8A EB BE 0A | :waitres                rdlong  data, mboxcmd wz
0C54(00F9) F8 00 54 5C |               if_nz     jmp     #:waitres
0C58(00FA) 8B EB BE 08 |                         rdlong  data, mboxdat
0C5C(00FB) 00 00 7C 5C | read_long_ret           ret
0C60(00FC) B7 D7 3E 85 | write_long              cmp     address, word_mask wc   'FIXME this only allows 64K RAM - FIXED allows any
0C64(00FD) 24 01 4C 5C |               if_nc     jmp     #out_long
0C68(00FE) 8B EB 3E 08 |                         wrlong  data, mboxdat
0C6C(00FF) 6B 13 BF A0 |                         mov     addr, address
0C70(0100) 09 12 FF 2C |                         shl     addr, #9
0C74(0101) 87 12 FF 50 |                         movs    addr, #WRITEVML
0C78(0102) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0C7C(0103) 8A 13 BF 0A | :waitdone               rdlong  addr, mboxcmd wz
0C80(0104) 03 01 54 5C |                   if_nz jmp     #:waitdone
0C84(0105) 00 00 7C 5C | write_long_ret          ret
0C88(0106)             | read_word
0C88(0106) 6B 13 BF A0 |                         mov     addr, address
0C8C(0107) 02 12 FF 6C |                         xor     addr, #%10              'XOR here is an endianess fix.
0C90(0108) 09 12 FF 2C |                         shl     addr, #9
0C94(0109) 83 12 FF 50 |                         movs    addr, #READVMW
0C98(010A) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0C9C(010B) 8A EB BE 0A | :waitres                rdlong  data, mboxcmd wz
0CA0(010C) 0B 01 54 5C |               if_nz     jmp     #:waitres
0CA4(010D) 8B EB BE 08 |                         rdlong  data, mboxdat
0CA8(010E) 00 00 7C 5C | read_word_ret           ret
0CAC(010F)             | write_word
0CAC(010F) 8B EB 3E 08 |                         wrlong  data, mboxdat
0CB0(0110) 6B 13 BF A0 |                         mov     addr, address
0CB4(0111) 02 12 FF 6C |                         xor     addr, #%10              'XOR here is an endianess fix.
0CB8(0112) 09 12 FF 2C |                         shl     addr, #9
0CBC(0113) 86 12 FF 50 |                         movs    addr, #WRITEVMW
0CC0(0114) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0CC4(0115) 8A 13 BF 0A | :waitdone               rdlong  addr, mboxcmd wz
0CC8(0116) 15 01 54 5C |                   if_nz jmp     #:waitdone
0CCC(0117) 00 00 7C 5C | write_word_ret          ret
0CD0(0118) B9 D7 3E 87 | in_long                 cmp     address, vhub_end wz, wc 'Check for HUB memory read
0CD4(0119) 2D 01 78 5C |               if_be     jmp     #read_hub_long
0CD8(011A) B8 D7 3E 86 |                         cmp     address, timer_address wz 'Check for timer read
0CDC(011B) F1 EB AA A0 |               if_z      mov     data, cnt
0CE0(011C) FB 00 68 5C |               if_z      jmp     #read_long_ret
0CE4(011D) 7A D7 3E 08 |                         wrlong  address, io_port_addr 'Set port address
0CE8(011E) 02 DE FE A0 |                         mov     temp, #io_cmd_in      'Set I/O command to IN
0CEC(011F) 78 DF 3E 08 |                         wrlong  temp, io_command_addr
0CF0(0120) 78 DF BE 0A | :wait                   rdlong  temp, io_command_addr wz 'Wait for command to be completed
0CF4(0121) 20 01 54 5C |               if_nz     jmp     #:wait
0CF8(0122) 7C EB BE 08 |                         rdlong  data, io_data_addr    'Get the port data
0CFC(0123) FB 00 7C 5C |                         jmp     #read_long_ret
0D00(0124) B9 D7 3E 87 | out_long                cmp     address, vhub_end wz, wc 'Check for HUB memory write
0D04(0125) 30 01 78 5C |               if_be     jmp     #write_hub_long
0D08(0126) 7A D7 3E 08 |                         wrlong  address, io_port_addr 'Set port address
0D0C(0127) 7C EB 3E 08 |                         wrlong  data, io_data_addr    'Set port data
0D10(0128) 01 DE FE A0 |                         mov     temp, #io_cmd_out     'Set I/O command to OUT
0D14(0129) 78 DF 3E 08 |                         wrlong  temp, io_command_addr
0D18(012A) 78 DF BE 0A | :wait                   rdlong  temp, io_command_addr wz 'Wait for command to be completed
0D1C(012B) 2A 01 54 5C |               if_nz     jmp     #:wait
0D20(012C) 05 01 7C 5C |                         jmp     #write_long_ret
0D24(012D) B7 D7 BE 84 | read_hub_long           sub     address, word_mask    'FIXME this only allows 64K RAM
0D28(012E) 6B EB BE 08 |                         rdlong  data, address
0D2C(012F) FB 00 7C 5C |                         jmp     #read_long_ret
0D30(0130) B7 D7 BE 84 | write_hub_long          sub     address, word_mask    'FIXME this only allows 64K RAM
0D34(0131) 6B EB 3E 08 |                         wrlong  data, address
0D38(0132) 05 01 7C 5C |                         jmp     #write_long_ret
0D3C(0133)             | fast_mul                ' account for sign
0D3C(0133) 73 E7 BE A9 |                         abs     tos, tos        wc
0D40(0134) 75 EB BE B0 |                         negc    data, data
0D44(0135) 75 EB BE A9 |                         abs     data, data      wc
0D48(0136) 73 FF BE A0 |                         mov     t2, tos
0D4C(0137) 75 FF BE 4C |                         max     t2, data
0D50(0138) 73 EB BE 48 |                         min     data, tos
0D54(0139) 75 EB BE B0 |                         negc    data, data
0D58(013A) 00 E6 FE A0 |                         mov     tos, #0
0D5C(013B) 01 FE FE 2B | :mul_loop               shr     t2, #1          wc,wz   ' get the low bit of t2
0D60(013C) 75 E7 B2 80 |         if_c            add     tos, data               ' if it was a 1, add adder to accumulator
0D64(013D) 01 EA FE 2C |                         shl     data, #1                ' shift the adder left by 1 bit
0D68(013E) 3B 01 54 5C |         if_nz           jmp     #:mul_loop              ' continue as long as there are no more 1's
0D6C(013F) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0D70(0140)             | fast_div                ' tos = tos / data
0D70(0140) 01 EE FE 62 |                         and     div_flags, #1   wz      ' keep only the 0 bit, and remember if it's a 0
0D74(0141) 75 FB BE A9 |                         abs     t1, data        wc
0D78(0142) 02 EE E2 68 |              if_z_and_c or      div_flags, #2           ' data was negative, and we're looking for quotient, so set bit 1 hi
0D7C(0143) 73 EB BE A9 |                         abs     data, tos       wc
0D80(0144) 02 EE F2 6C |               if_c      xor     div_flags, #2           ' tos was negative, invert bit 1 (quotient or remainder)
0D84(0145) 01 FE FE A5 |                         neg     t2, #1          wc      ' count how many times we shift (negative)
0D88(0146) 01 FA FE 35 | :align_loop             rcl     t1, #1          wc      ' left shift the divisior, marking when we hit a 1
0D8C(0147) 46 FF CE E4 |               if_nc     djnz    t2, #:align_loop        ' the divisior MUST NOT BE 0
0D90(0148) 01 FA FE 30 |                         rcr     t1, #1                  ' restore the 1 bit we just nuked
0D94(0149) 7F FF BE A4 |                         neg     t2, t2                  ' how many times did we shift? (we started at -1 and counted down)
0D98(014A) 00 E6 FE A0 |                         mov     tos, #0
0D9C(014B) 7D EB BE E1 | :div_loop               cmpsub  data, t1        wc      ' does the divisor fit into the dividend?
0DA0(014C) 01 E6 FE 34 |                         rcl     tos, #1                 ' if it did, store a one while shifting left
0DA4(014D) 01 FA FE 28 |                         shr     t1, #1                  '
0DA8(014E) 4B FF FE E4 |                         djnz    t2, #:div_loop
0DAC(014F) 01 EE FE 2B |                         shr     div_flags, #1   wc,wz
0DB0(0150) 75 E7 B2 A0 |               if_c      mov     tos, data               ' user wanted the remainder, not the quotient
0DB4(0151) 73 E7 BE BC |                         negnz   tos, tos                ' need to invert the result
0DB8(0152) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0DBC(0153) 07 E6 FE 2C | zpu_im_next             shl     tos, #7
0DC0(0154) 75 E7 BE 68 |                         or      tos, data
0DC4(0155) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0DC8(0156) E0 D0 FD 5C | zpu_im_first            call    #push_tos
0DCC(0157) 75 E7 BE A0 |                         mov     tos, data
0DD0(0158) 19 E6 FE 2C |                         shl     tos, #(32 - 7)          'Sign extend
0DD4(0159) 19 E6 FE 38 |                         sar     tos, #(32 - 7)
0DD8(015A) 53 CB FE 50 |                         movs    which_im, #zpu_im_next  'N.B. Drops through to done_and_inc_pc
0DDC(015B) 01 E0 FE 80 | done_and_inc_pc         add     pc, #1
0DE0(015C)             | done
0DE0(015C)             | execute
0DE0(015C) 70 13 BF A0 |                         mov     addr, pc
0DE4(015D) 03 12 FF 6C |                         xor     addr, #%11              'XOR here is an endianess fix.
0DE8(015E) 09 12 FF 2C |                         shl     addr, #9
0DEC(015F) 82 12 FF 50 |                         movs    addr, #READVMB
0DF0(0160) 8A 13 3F 08 |                         wrlong  addr, mboxcmd
0DF4(0161) 8A EB BE 0A | :waitres                rdlong  data, mboxcmd wz
0DF8(0162) 61 01 54 5C |               if_nz     jmp     #:waitres
0DFC(0163) 8B EB BE 00 |                         rdbyte  data, mboxdat
0E00(0164) 80 EA FE E1 |                         cmpsub  data, #$80 wc           'Check for IM instruction. This saves table lookup
0E04(0165) 56 01 70 5C | which_im      if_c      jmp     #zpu_im_first           'for the most common op. 7% fibo speed gain!
0E08(0166) 56 CB FE 50 |                         movs    which_im, #zpu_im_first 'Self modifying code at which_im selects, first or subsequent IM.
0E0C(0167) 75 D7 BE A0 |                         mov     address, data           'Some opcodes contains address offsets.
0E10(0168) 74 EB BE 80 |                         add     data, dispatch_tab_addr
0E14(0169) 75 DF BE 00 |                         rdbyte  temp, data
0E18(016A) 6F 01 3C 5C |                         jmp     temp                    'No # here we are jumping through temp.
0E1C(016B)             | init
0E1C(016B) F0 D7 BE A0 | address                 mov     address, par             'Pick up first 6 longs of PAR block
0E20(016C) 6B D9 BE 08 | zpu_memory_addr         rdlong  zpu_memory_addr, address 'HUB address of the ZPU memory area
0E24(016D) 04 D6 FE 80 | memp                    add     address, #4              'Temporary pointer into ZPU memory space
0E28(016E) 6B DD BE 08 | zpu_memory_sz           rdlong  zpu_memory_sz, address   'Size of ZPU memory area in bytes
0E2C(016F) 04 D6 FE 80 | temp                    add     address, #4          'For temp operands etc
0E30(0170) 6B E1 BE 08 | pc                      rdlong  pc, address          'ZPU Program Counter
0E34(0171) 04 D6 FE 80 | instruction             add     address, #4          'Opcode being executed.
0E38(0172) 6B E5 BE 08 | sp                      rdlong  sp, address          'ZPU Stack Pointer
0E3C(0173) 04 D6 FE 80 | tos                     add     address, #4          'Top Of Stack
0E40(0174) 6B E9 BE 08 | dispatch_tab_addr       rdlong  dispatch_tab_addr, address'HUB address of instruction dispatch table
0E44(0175) 04 D6 FE 80 | data                    add     address, #4          'Data parameter for read, write etc
0E48(0176) 04 D6 FE 80 | cpu                     add     address, #4          'The CPU type given by the CONGIG op.
0E4C(0177) 6B DF BE 08 | div_flags               rdlong  temp, address        '7th par item is address of ZOG I/O mailbox
0E50(0178) 6F F1 BE A0 | io_command_addr         mov     io_command_addr, temp'HUB address of I/O command byte.
0E54(0179) 04 DE FE 80 | x                       add     temp, #4             'Maths var.
0E58(017A) 6F F5 BE A0 | io_port_addr            mov     io_port_addr, temp   'HUB address of I/ port number
0E5C(017B) 04 DE FE 80 | y                       add     temp, #4             'Maths var.
0E60(017C) 6F F9 BE A0 | io_data_addr            mov     io_data_addr, temp   'HUB address of I/O data
0E64(017D) 04 DE FE 80 | t1                      add     temp, #4             'Maths var.
0E68(017E) 6F FD BE A0 | pc_addr                 mov     pc_addr, temp        'HUB address of PC
0E6C(017F) 04 DE FE 80 | t2                      add     temp, #4             'Maths var.
0E70(0180) 6F 01 BF A0 | sp_addr                 mov     sp_addr, temp        'HUB address of SP
0E74(0181) 04 DE FE 80 | coginit_dest            add     temp, #4             'Used for coginit instruction.
0E78(0182) 6F 05 BF A0 | tos_addr                mov     tos_addr, temp       'HUB address of tos
0E7C(0183) 04 DE FE 80 |                         add     temp, #4
0E80(0184) 6F 09 BF A0 | dm_addr                 mov     dm_addr, temp        'HUB address of decode mask
0E84(0185) 04 DE FE 80 |                         add     temp, #4             'Flag for the IM instruction
0E88(0186) 6F 0D BF A0 | debug_addr              mov     debug_addr, temp     'HUB address of debug register
0E8C(0187) 04 D6 FE 80 |                         add     address, #4
0E90(0188) 6B DF BE 08 |                         rdlong  temp, address        '8th par item is address of VMCog mailbox
0E94(0189) 6F 15 BF A0 | addr                    mov     mboxcmd, temp        'Address we want to read, can be PC or whatever
0E98(018A) 08 DE FE 80 | mboxcmd                 add     temp, #8             'Pointer to first long of VMCOG mailbox (+0 offset)
0E9C(018B) 6F 17 BF A0 | mboxdat                 mov     mboxdat, temp        'Pointer to second long of VMCOG mailbox (+4 offset)
0EA0(018C) 5C 01 7C 5C |                         jmp     #execute
0EA4(018D) 7E E1 3E 08 | break                   wrlong  pc, pc_addr             'Dump registers to HUB.
0EA8(018E) 80 E5 3E 08 |                         wrlong  sp, sp_addr
0EAC(018F) 82 E7 3E 08 |                         wrlong  tos, tos_addr
0EB0(0190) 84 CB 3E 08 |                         wrlong  which_im, dm_addr
0EB4(0191) 03 DE FE A0 |                         mov     temp, #io_cmd_break     'Set I/O command to BREAK
0EB8(0192) 78 DF 3E 08 |                         wrlong  temp, io_command_addr
0EBC(0193) 78 DF BE 0A | :wait                   rdlong  temp, io_command_addr wz
0EC0(0194) 93 01 54 5C |               if_nz     jmp     #:wait
0EC4(0195) 00 00 7C 5C | break_ret               ret
0EC8(0196) 72 D7 BE A0 | syscall                 mov     address, sp             'Get syscall ID from stack
0ECC(0197) 08 D6 FE 80 |                         add     address, #8
0ED0(0198) F2 F6 FD 5C |                         call    #read_long
0ED4(0199) BA EB 3E 86 |                         cmp     data, sys_cognew_ wz    'Is it SYS_cognew?
0ED8(019A) AE 01 54 5C |               if_nz     jmp     #syscall_external_handler
0EDC(019B)             | handle_sys_cognew
0EDC(019B) 08 02 FF A0 |                         mov     coginit_dest, #%1000    'Set cognew "any cog will do" bit
0EE0(019C) 08 D6 FE 80 |                         add     address, #8             'Get HUB address of PASM code to run
0EE4(019D) F2 F6 FD 5C |                         call    #read_long
0EE8(019E) 6C EB BE 80 |                         add     data, zpu_memory_addr   'Map to HUB address
0EEC(019F) B7 EB BE 60 |                         and     data, word_mask         'Only 16 bit address
0EF0(01A0) 02 EA FE 2C |                         shl     data, #2                'Shift into bits 17:4 (only high 14 bits required)
0EF4(01A1) 75 03 BF 68 |                         or      coginit_dest, data      'Place in dest for coginit
0EF8(01A2) 04 D6 FE 80 |                         add     address, #4             'Now offset 20 from SP
0EFC(01A3) F2 F6 FD 5C |                         call    #read_long              'Get address of PAR data
0F00(01A4) 6C EB BE 80 |                         add     data, zpu_memory_addr   'Map to HUB address
0F04(01A5) B7 EB BE 60 |                         and     data, word_mask         'Only 16 bit address
0F08(01A6) 10 EA FE 2C |                         shl     data, #16               'Move to bits 31:18 (only high 14 bits required)
0F0C(01A7) 75 03 BF 68 |                         or      coginit_dest, data      'Combine PASM addr and PAR addr
0F10(01A8) 02 02 FF 0F |                         coginit coginit_dest wc,wz,wr
0F14(01A9) B5 03 B3 A0 |               if_c      mov     coginit_dest, minus_one 'Return -1 if no free cog
0F18(01AA) 00 D6 FE A0 |                         mov     address, #0             'Error is returned in ZPU reg 0, which is address 0
0F1C(01AB) 81 EB BE A0 |                         mov     data, coginit_dest
0F20(01AC) FC 0A FE 5C |                         call    #write_long
0F24(01AD) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0F28(01AE)             | syscall_external_handler
0F28(01AE) 80 E5 3E 08 |                         wrlong  sp, sp_addr
0F2C(01AF) 04 DE FE A0 |                         mov     temp, #io_cmd_syscall   'Set I/O command to SYSCALL
0F30(01B0) 78 DF 3E 08 |                         wrlong  temp, io_command_addr
0F34(01B1) 78 DF BE 0A | :wait                   rdlong  temp, io_command_addr wz'Wait for command completion
0F38(01B2) B1 01 54 5C |               if_nz     jmp     #:wait
0F3C(01B3) 80 E5 BE 08 |                         rdlong  sp, sp_addr
0F40(01B4) 5B 01 7C 5C |                         jmp     #done_and_inc_pc
0F44(01B5) FF FF FF FF | minus_one               long $FFFFFFFF
0F48(01B6) FE FF FF FF | minus_two               long $FFFFFFFE
0F4C(01B7) FF FF 00 00 | word_mask               long $0000FFFF
0F50(01B8) 00 01 00 80 | timer_address           long $80000100
0F54(01B9) FF FF FF 01 | vhub_end                long $01FFFFFF   '32kk - 1
0F58(01BA) 40 1F 00 00 | sys_cognew_             long SYS_cognew
0F5C(01BB)             |                         fit     $1F0
0F5C(01BB)             | There are 53 ($035) Longs left in the cog
0F5C(01BB)             | dispatch_table
0F5C(01BB) 01          | {00}    byte  zpu_breakpoint
0F5D(01BB) DE          | {01}    byte  zpu_illegal
0F5E(01BB) 5A          | {02}    byte  zpu_pushsp
0F5F(01BB) DE          | {03}    byte  zpu_illegal
0F60(01BC) 49          | {04}    byte  zpu_poppc
0F61(01BC) 53          | {05}    byte  zpu_add
0F62(01BC) 64          | {06}    byte  zpu_and
0F63(01BC) 37          | {07}    byte  zpu_or
0F64(01BD) 3C          | {08}    byte  zpu_load
0F65(01BD) 3A          | {09}    byte  zpu_not
0F66(01BD) 51          | {0A}    byte  zpu_flip
0F67(01BD) 63          | {0B}    byte  zpu_nop
0F68(01BE) 43          | {0C}    byte  zpu_store
0F69(01BE) 5E          | {0D}    byte  zpu_popsp
0F6A(01BE) DE          | {0E}    byte  zpu_illegal
0F6B(01BE) DE          | {0F}    byte  zpu_illegal
0F6C(01BF) 03          | {10}    byte  zpu_addsp_0
0F6D(01BF) 05          | {11}    byte  zpu_addsp
0F6E(01BF) 05          | {12}    byte  zpu_addsp
0F6F(01BF) 05          | {13}    byte  zpu_addsp
0F70(01C0) 05          | {14}    byte  zpu_addsp
0F71(01C0) 05          | {15}    byte  zpu_addsp
0F72(01C0) 05          | {16}    byte  zpu_addsp
0F73(01C0) 05          | {17}    byte  zpu_addsp
0F74(01C1) 05          | {18}    byte  zpu_addsp
0F75(01C1) 05          | {19}    byte  zpu_addsp
0F76(01C1) 05          | {1A}    byte  zpu_addsp
0F77(01C1) 05          | {1B}    byte  zpu_addsp
0F78(01C2) 05          | {1C}    byte  zpu_addsp
0F79(01C2) 05          | {1D}    byte  zpu_addsp
0F7A(01C2) 05          | {1E}    byte  zpu_addsp
0F7B(01C2) 05          | {1F}    byte  zpu_addsp
0F7C(01C3) DE          | {20}    byte  not_implemented' zpu_emulate
0F7D(01C3) DE          | {21}    byte  not_implemented' zpu_emulate
0F7E(01C3) 7F          | {22}    byte  zpu_loadh
0F7F(01C3) 83          | {23}    byte  zpu_storeh
0F80(01C4) 89          | {24}    byte  zpu_lessthan
0F81(01C4) 8E          | {25}    byte  zpu_lessthanorequal
0F82(01C4) 93          | {26}    byte  zpu_ulessthan
0F83(01C4) 98          | {27}    byte  zpu_ulessthanorequal
0F84(01C5) 9D          | {28}    byte  zpu_swap
0F85(01C5) AF          | {29}    byte  zpu_mult
0F86(01C5) B9          | {2A}    byte  zpu_lshiftright
0F87(01C5) BE          | {2B}    byte  zpu_ashiftleft
0F88(01C6) C3          | {2C}    byte  zpu_ashiftright
0F89(01C6) C8          | {2D}    byte  zpu_call
0F8A(01C6) D2          | {2E}    byte  zpu_eq
0F8B(01C6) D7          | {2F}    byte  zpu_neq
0F8C(01C7) DB          | {30}    byte  zpu_neg
0F8D(01C7) 56          | {31}    byte  zpu_sub
0F8E(01C7) 67          | {32}    byte  zpu_xor
0F8F(01C7) 6A          | {33}    byte  zpu_loadb
0F90(01C8) 73          | {34}    byte  zpu_storeb
0F91(01C8) B1          | {35}    byte  zpu_div
0F92(01C8) B5          | {36}    byte  zpu_mod
0F93(01C8) A3          | {37}    byte  zpu_eqbranch
0F94(01C9) A9          | {38}    byte  zpu_neqbranch
0F95(01C9) 4D          | {39}    byte  zpu_poppcrel
0F96(01C9) 30          | {3A}    byte  zpu_config
0F97(01C9) 34          | {3B}    byte  zpu_pushpc
0F98(01CA) DD          | {3C}    byte  zpu_syscall
0F99(01CA) 40          | {3D}    byte  zpu_pushspadd
0F9A(01CA) 9F          | {3E}    byte  zpu_mult16x16
0F9B(01CA) CD          | {3F}    byte  zpu_callpcrel
0F9C(01CB) 27          | {40}    byte  zpu_storesp
0F9D(01CB) 27          | {41}    byte  zpu_storesp
0F9E(01CB) 27          | {42}    byte  zpu_storesp
0F9F(01CB) 27          | {43}    byte  zpu_storesp
0FA0(01CC) 27          | {44}    byte  zpu_storesp
0FA1(01CC) 27          | {45}    byte  zpu_storesp
0FA2(01CC) 27          | {46}    byte  zpu_storesp
0FA3(01CC) 27          | {47}    byte  zpu_storesp
0FA4(01CD) 27          | {48}    byte  zpu_storesp
0FA5(01CD) 27          | {49}    byte  zpu_storesp
0FA6(01CD) 27          | {4A}    byte  zpu_storesp
0FA7(01CD) 27          | {4B}    byte  zpu_storesp
0FA8(01CE) 27          | {4C}    byte  zpu_storesp
0FA9(01CE) 27          | {4D}    byte  zpu_storesp
0FAA(01CE) 27          | {4E}    byte  zpu_storesp
0FAB(01CE) 27          | {4F}    byte  zpu_storesp
0FAC(01CF) 1C          | {50}    byte  zpu_storesp_tos
0FAD(01CF) 1F          | {51}    byte  zpu_storesp_hi
0FAE(01CF) 1F          | {52}    byte  zpu_storesp_hi
0FAF(01CF) 1F          | {53}    byte  zpu_storesp_hi
0FB0(01D0) 1F          | {54}    byte  zpu_storesp_hi
0FB1(01D0) 1F          | {55}    byte  zpu_storesp_hi
0FB2(01D0) 1F          | {56}    byte  zpu_storesp_hi
0FB3(01D0) 1F          | {57}    byte  zpu_storesp_hi
0FB4(01D1) 1F          | {58}    byte  zpu_storesp_hi
0FB5(01D1) 1F          | {59}    byte  zpu_storesp_hi
0FB6(01D1) 1F          | {5A}    byte  zpu_storesp_hi
0FB7(01D1) 1F          | {5B}    byte  zpu_storesp_hi
0FB8(01D2) 1F          | {5C}    byte  zpu_storesp_hi
0FB9(01D2) 1F          | {5D}    byte  zpu_storesp_hi
0FBA(01D2) 1F          | {5E}    byte  zpu_storesp_hi
0FBB(01D2) 1F          | {5F}    byte  zpu_storesp_hi
0FBC(01D3) 14          | {60}    byte  zpu_loadsp
0FBD(01D3) 14          | {61}    byte  zpu_loadsp
0FBE(01D3) 14          | {62}    byte  zpu_loadsp
0FBF(01D3) 14          | {63}    byte  zpu_loadsp
0FC0(01D4) 14          | {64}    byte  zpu_loadsp
0FC1(01D4) 14          | {65}    byte  zpu_loadsp
0FC2(01D4) 14          | {66}    byte  zpu_loadsp
0FC3(01D4) 14          | {67}    byte  zpu_loadsp
0FC4(01D5) 14          | {68}    byte  zpu_loadsp
0FC5(01D5) 14          | {69}    byte  zpu_loadsp
0FC6(01D5) 14          | {6A}    byte  zpu_loadsp
0FC7(01D5) 14          | {6B}    byte  zpu_loadsp
0FC8(01D6) 14          | {6C}    byte  zpu_loadsp
0FC9(01D6) 14          | {6D}    byte  zpu_loadsp
0FCA(01D6) 14          | {6E}    byte  zpu_loadsp
0FCB(01D6) 14          | {6F}    byte  zpu_loadsp
0FCC(01D7) 0B          | {70}    byte  zpu_loadsp_tos
0FCD(01D7) 0D          | {71}    byte  zpu_loadsp_hi
0FCE(01D7) 0D          | {72}    byte  zpu_loadsp_hi
0FCF(01D7) 0D          | {73}    byte  zpu_loadsp_hi
0FD0(01D8) 0D          | {74}    byte  zpu_loadsp_hi
0FD1(01D8) 0D          | {75}    byte  zpu_loadsp_hi
0FD2(01D8) 0D          | {76}    byte  zpu_loadsp_hi
0FD3(01D8) 0D          | {77}    byte  zpu_loadsp_hi
0FD4(01D9) 0D          | {78}    byte  zpu_loadsp_hi
0FD5(01D9) 0D          | {79}    byte  zpu_loadsp_hi
0FD6(01D9) 0D          | {7A}    byte  zpu_loadsp_hi
0FD7(01D9) 0D          | {7B}    byte  zpu_loadsp_hi
0FD8(01DA) 0D          | {7C}    byte  zpu_loadsp_hi
0FD9(01DA) 0D          | {7D}    byte  zpu_loadsp_hi
0FDA(01DA) 0D          | {7E}    byte  zpu_loadsp_hi
0FDB(01DA) 0D          | {7F}    byte  zpu_loadsp_hi
|===========================================================================|
|===========================================================================|
Spin Block start with 1 Parameters and 1 Extra Stack Longs. Method 1
PUB start (params) | okay

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - params
Local Variable  DBASE:0008 - okay
|===========================================================================|
184                        okay := cog := cognew(@enter, params) + 1   'Start emulator in a new COG
Addr : 0FDC:             34  : Constant 0 $FFFFFFFF
Addr : 0FDD:          C7 14  : Memory Op Long PBASE + ADDRESS Address = 0014
Addr : 0FDF:             64  : Variable Operation Local Offset - 1 Read
Addr : 0FE0:             28  : CogInit(Id, Addr, Ptr) Push
Addr : 0FE1:             36  : Constant 2 $00000001
Addr : 0FE2:             EC  : Math Op +     
Addr : 0FE3:          42 80  : Variable Operation Global Offset - 0 Assign Write Push
Addr : 0FE5:             69  : Variable Operation Local Offset - 2 Write
Addr : 0FE6:             32  : Return        
|===========================================================================|
Spin Block stop with 0 Parameters and 0 Extra Stack Longs. Method 2
PUB stop

Local Parameter DBASE:0000 - Result
|===========================================================================|
Addr : 0FE7:             32  : Return        
|===========================================================================|
Spin Block getdispatch_table with 0 Parameters and 0 Extra Stack Longs. Method 3
PUB getdispatch_table

Local Parameter DBASE:0000 - Result
|===========================================================================|
190                        return @dispatch_table
Addr : 0FE8:       C7 87 00  : Memory Op Long PBASE + ADDRESS Address = 0700
Addr : 0FEB:             33  : Return value  
Addr : 0FEC: Data : 32                       2
|===========================================================================|
Spin Block getzog with 0 Parameters and 0 Extra Stack Longs. Method 4
PUB getzog

Local Parameter DBASE:0000 - Result
|===========================================================================|
193                        return @enter
Addr : 0FED:          C7 14  : Memory Op Long PBASE + ADDRESS Address = 0014
Addr : 0FEF:             33  : Return value  
Addr : 0FF0: Data : 32                       2
|===========================================================================|
Object FullDuplexSerialPlus
Object Base is 0FF4
|===========================================================================|
Object Constants
|===========================================================================|
|===========================================================================|
VBASE Global Variables
|===========================================================================|
VBASE : 0000 LONG Size 0004 Variable cog
VBASE : 0004 LONG Size 0004 Variable rx_head
VBASE : 0008 LONG Size 0004 Variable rx_tail
VBASE : 000C LONG Size 0004 Variable tx_head
VBASE : 0010 LONG Size 0004 Variable tx_tail
VBASE : 0014 LONG Size 0004 Variable rx_pin
VBASE : 0018 LONG Size 0004 Variable tx_pin
VBASE : 001C LONG Size 0004 Variable rxtx_mode
VBASE : 0020 LONG Size 0004 Variable bit_ticks
VBASE : 0024 BYTE Size 0010 Variable rx_buffer
VBASE : 0034 BYTE Size 0010 Variable tx_buffer
|===========================================================================|
Object DAT Blocks
|===========================================================================|
1054(0000)             |                         org
1054(0000) F0 A9 BC A0 | entry                   mov     t1,par                'get structure address
1058(0001) 10 A8 FC 80 |                         add     t1,#4 << 2            'skip past heads and tails
105C(0002) 54 AA BC 08 |                         rdlong  t2,t1                 'get rx_pin
1060(0003) 01 B2 FC A0 |                         mov     rxmask,#1
1064(0004) 55 B2 BC 2C |                         shl     rxmask,t2
1068(0005) 04 A8 FC 80 |                         add     t1,#4                 'get tx_pin
106C(0006) 54 AA BC 08 |                         rdlong  t2,t1
1070(0007) 01 BE FC A0 |                         mov     txmask,#1
1074(0008) 55 BE BC 2C |                         shl     txmask,t2
1078(0009) 04 A8 FC 80 |                         add     t1,#4                 'get rxtx_mode
107C(000A) 54 AE BC 08 |                         rdlong  rxtxmode,t1
1080(000B) 04 A8 FC 80 |                         add     t1,#4                 'get bit_ticks
1084(000C) 54 B0 BC 08 |                         rdlong  bitticks,t1
1088(000D) 04 A8 FC 80 |                         add     t1, #4                'get buffer_ptr
108C(000E) 54 B4 BC A0 |                         mov     rxbuff, t1
1090(000F) 5A C0 BC A0 |                         mov     txbuff,rxbuff
1094(0010) 10 C0 FC 80 |                         add     txbuff,#16
1098(0011) 04 AE 7C 62 |                         test    rxtxmode,#%100  wz    'init tx pin according to mode
109C(0012) 02 AE 7C 61 |                         test    rxtxmode,#%010  wc
10A0(0013) 5F E8 9B 68 |         if_z_ne_c       or      outa,txmask
10A4(0014) 5F EC AB 68 |         if_z            or      dira,txmask
10A8(0015) 33 C8 FC A0 |                         mov     txcode,#transmit      'initialize ping-pong multitasking
10AC(0016) 64 BC BC 5C | receive                 jmpret  rxcode,txcode         'run chunk of tx code, then return
10B0(0017) 01 AE 7C 62 |                         test    rxtxmode,#%001  wz    'wait for start bit on rx pin
10B4(0018) F2 B3 3C 61 |                         test    rxmask,ina      wc
10B8(0019) 16 00 64 5C |         if_z_eq_c       jmp     #receive
10BC(001A) 09 B8 FC A0 |                         mov     rxbits,#9             'ready to receive byte
10C0(001B) 58 BA BC A0 |                         mov     rxcnt,bitticks
10C4(001C) 01 BA FC 28 |                         shr     rxcnt,#1
10C8(001D) F1 BB BC 80 |                         add     rxcnt,cnt                          
10CC(001E) 58 BA BC 80 | :bit                    add     rxcnt,bitticks        'ready next bit period
10D0(001F) 64 BC BC 5C | :wait                   jmpret  rxcode,txcode         'run chunk of tx code, then return
10D4(0020) 5D A8 BC A0 |                         mov     t1,rxcnt              'check if bit receive period done
10D8(0021) F1 A9 BC 84 |                         sub     t1,cnt
10DC(0022) 00 A8 7C C1 |                         cmps    t1,#0           wc
10E0(0023) 1F 00 4C 5C |         if_nc           jmp     #:wait
10E4(0024) F2 B3 3C 61 |                         test    rxmask,ina      wc    'receive bit on rx pin
10E8(0025) 01 B6 FC 30 |                         rcr     rxdata,#1
10EC(0026) 1E B8 FC E4 |                         djnz    rxbits,#:bit
10F0(0027) 17 B6 FC 28 |                         shr     rxdata,#32-9          'justify and trim received byte
10F4(0028) FF B6 FC 60 |                         and     rxdata,#$FF
10F8(0029) 01 AE 7C 62 |                         test    rxtxmode,#%001  wz    'if rx inverted, invert byte
10FC(002A) FF B6 D4 6C |         if_nz           xor     rxdata,#$FF
1100(002B) F0 AB BC 08 |                         rdlong  t2,par                'save received byte and inc head
1104(002C) 5A AA BC 80 |                         add     t2,rxbuff
1108(002D) 55 B6 3C 00 |                         wrbyte  rxdata,t2
110C(002E) 5A AA BC 84 |                         sub     t2,rxbuff
1110(002F) 01 AA FC 80 |                         add     t2,#1
1114(0030) 0F AA FC 60 |                         and     t2,#$0F
1118(0031) F0 AB 3C 08 |                         wrlong  t2,par
111C(0032) 16 00 7C 5C |                         jmp     #receive              'byte done, receive next byte
1120(0033) 5E C8 BC 5C | transmit                jmpret  txcode,rxcode         'run chunk of rx code, then return
1124(0034) F0 A9 BC A0 |                         mov     t1,par                'check for head <> tail
1128(0035) 08 A8 FC 80 |                         add     t1,#2 << 2
112C(0036) 54 AA BC 08 |                         rdlong  t2,t1
1130(0037) 04 A8 FC 80 |                         add     t1,#1 << 2
1134(0038) 54 AC BC 08 |                         rdlong  t3,t1
1138(0039) 56 AA 3C 86 |                         cmp     t2,t3           wz
113C(003A) 33 00 68 5C |         if_z            jmp     #transmit
1140(003B) 60 AC BC 80 |                         add     t3,txbuff             'get byte and inc tail
1144(003C) 56 C2 BC 00 |                         rdbyte  txdata,t3
1148(003D) 60 AC BC 84 |                         sub     t3,txbuff
114C(003E) 01 AC FC 80 |                         add     t3,#1
1150(003F) 0F AC FC 60 |                         and     t3,#$0F
1154(0040) 54 AC 3C 08 |                         wrlong  t3,t1
1158(0041) 00 C3 FC 68 |                         or      txdata,#$100          'ready byte to transmit
115C(0042) 02 C2 FC 2C |                         shl     txdata,#2
1160(0043) 01 C2 FC 68 |                         or      txdata,#1
1164(0044) 0B C4 FC A0 |                         mov     txbits,#11
1168(0045) F1 C7 BC A0 |                         mov     txcnt,cnt
116C(0046) 04 AE 7C 62 | :bit                    test    rxtxmode,#%100  wz    'output bit on tx pin 
1170(0047) 02 AE 7C 61 |                         test    rxtxmode,#%010  wc    'according to mode
1174(0048) 01 C2 E0 6C |         if_z_and_c      xor     txdata,#1
1178(0049) 01 C2 FC 29 |                         shr     txdata,#1       wc
117C(004A) 5F E8 AB 70 |         if_z            muxc    outa,txmask        
1180(004B) 5F EC 97 74 |         if_nz           muxnc   dira,txmask
1184(004C) 58 C6 BC 80 |                         add     txcnt,bitticks        'ready next cnt
1188(004D) 5E C8 BC 5C | :wait                   jmpret  txcode,rxcode         'run chunk of rx code, then return
118C(004E) 63 A8 BC A0 |                         mov     t1,txcnt              'check if bit transmit period done
1190(004F) F1 A9 BC 84 |                         sub     t1,cnt
1194(0050) 00 A8 7C C1 |                         cmps    t1,#0           wc
1198(0051) 4D 00 4C 5C |         if_nc           jmp     #:wait
119C(0052) 46 C4 FC E4 |                         djnz    txbits,#:bit          'another bit to transmit?
11A0(0053) 33 00 7C 5C |                         jmp     #transmit             'byte done, transmit next byte
11A4(0054)             | t1                      res     1
11A4(0055)             | t2                      res     1
11A4(0056)             | t3                      res     1
11A4(0057)             | rxtxmode                res     1
11A4(0058)             | bitticks                res     1
11A4(0059)             | rxmask                  res     1
11A4(005A)             | rxbuff                  res     1
11A4(005B)             | rxdata                  res     1
11A4(005C)             | rxbits                  res     1
11A4(005D)             | rxcnt                   res     1
11A4(005E)             | rxcode                  res     1
11A4(005F)             | txmask                  res     1
11A4(0060)             | txbuff                  res     1
11A4(0061)             | txdata                  res     1
11A4(0062)             | txbits                  res     1
11A4(0063)             | txcnt                   res     1
11A4(0064)             | txcode                  res     1
|===========================================================================|
|===========================================================================|
Spin Block start with 4 Parameters and 0 Extra Stack Longs. Method 1
PUB start(rxpin, txpin, mode, baudrate) : okay

Local Parameter DBASE:0000 - okay
Local Parameter DBASE:0004 - rxpin
Local Parameter DBASE:0008 - txpin
Local Parameter DBASE:000C - mode
Local Parameter DBASE:0010 - baudrate
|===========================================================================|
75                        stop
Addr : 11A4:             01  : Drop Anchor   
Addr : 11A5:          05 03  : Call Sub 3    
76                        longfill(@rx_head, 0, 4)
Addr : 11A7:             47  : Variable Operation Global Offset - 1 Address
Addr : 11A8:             35  : Constant 1 $00000000
Addr : 11A9:          37 01  : Constant Mask Y=1 00000004 4
Addr : 11AB:             1A  : LongFill(Start, Value, Count)
77                        longmove(@rx_pin, @rxpin, 3)
Addr : 11AC:             57  : Variable Operation Global Offset - 5 Address
Addr : 11AD:             67  : Variable Operation Local Offset - 1 Address
Addr : 11AE:          37 21  : Constant Mask Y=33 Decrement 00000003 3
Addr : 11B0:             1E  : LongMove(To, From, Count)
78                        bit_ticks := clkfreq / baudrate
Addr : 11B1:             35  : Constant 1 $00000000
Addr : 11B2:             C0  : Memory Op Long POP Address READ 
Addr : 11B3:             70  : Variable Operation Local Offset - 4 Read
Addr : 11B4:             F6  : Math Op /     
Addr : 11B5:          C9 20  : Memory Op Long VBASE + WRITE Address = 0020
79                        okay := cog := cognew(@entry, @rx_head) + 1
Addr : 11B7:             34  : Constant 0 $FFFFFFFF
Addr : 11B8:          C7 60  : Memory Op Long PBASE + ADDRESS Address = 0060
Addr : 11BA:             47  : Variable Operation Global Offset - 1 Address
Addr : 11BB:             28  : CogInit(Id, Addr, Ptr) Push
Addr : 11BC:             36  : Constant 2 $00000001
Addr : 11BD:             EC  : Math Op +     
Addr : 11BE:          42 80  : Variable Operation Global Offset - 0 Assign Write Push
Addr : 11C0:             61  : Variable Operation Local Offset - 0 Write
Addr : 11C1:             32  : Return        
|===========================================================================|
Spin Block getPasmAddress with 0 Parameters and 0 Extra Stack Longs. Method 2
PUB getPasmAddress

Local Parameter DBASE:0000 - Result
|===========================================================================|
82                        return @entry
Addr : 11C2:          C7 60  : Memory Op Long PBASE + ADDRESS Address = 0060
Addr : 11C4:             33  : Return value  
Addr : 11C5: Data : 32                       2
|===========================================================================|
Spin Block stop with 0 Parameters and 0 Extra Stack Longs. Method 3
PUB stop

Local Parameter DBASE:0000 - Result
|===========================================================================|
89                        if cog
Addr : 11C6:             40  : Variable Operation Global Offset - 0 Read
Addr : 11C7: JZ Label0002
Addr : 11C7:          0A 05  : jz Address = 11CE 5
90                          cogstop(cog~ - 1)
Addr : 11C9:          42 98  : Variable Operation Global Offset - 0 Assign VAR~ Post-clear Push
Addr : 11CB:             36  : Constant 2 $00000001
Addr : 11CC:             ED  : Math Op -     
Addr : 11CD:             21  : CogStop(id)   
Addr : 11CE: Label0002
Addr : 11CE: Label0003
91                        longfill(@rx_head, 0, 8)
Addr : 11CE:             47  : Variable Operation Global Offset - 1 Address
Addr : 11CF:             35  : Constant 1 $00000000
Addr : 11D0:          37 02  : Constant Mask Y=2 00000008 8
Addr : 11D2:             1A  : LongFill(Start, Value, Count)
Addr : 11D3:             32  : Return        
|===========================================================================|
Spin Block tx with 1 Parameters and 0 Extra Stack Longs. Method 4
PUB tx(txbyte)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - txbyte
|===========================================================================|
98                        repeat until (tx_tail <> (tx_head + 1) & $F)
Addr : 11D4: Label0002
Addr : 11D4:             50  : Variable Operation Global Offset - 4 Read
Addr : 11D5:             4C  : Variable Operation Global Offset - 3 Read
Addr : 11D6:             36  : Constant 2 $00000001
Addr : 11D7:             EC  : Math Op +     
Addr : 11D8:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 11DA:             E8  : Math Op &     
Addr : 11DB:             FB  : Math Op <>    
Addr : 11DC: JNZ Label0004
Addr : 11DC:          0B 02  : jnz Address = 11E0 2
Addr : 11DE: Label0003
Addr : 11DE: JMP Label0002
Addr : 11DE:          04 74  : Jmp 11D4 -12  
Addr : 11E0: Label0004
99                        tx_buffer[tx_head] := txbyte
Addr : 11E0:             64  : Variable Operation Local Offset - 1 Read
Addr : 11E1:             4C  : Variable Operation Global Offset - 3 Read
Addr : 11E2:          99 34  : Memory Op Byte VBASE + POP Index WRITE Address = 0034
100                        tx_head := (tx_head + 1) & $F
Addr : 11E4:             4C  : Variable Operation Global Offset - 3 Read
Addr : 11E5:             36  : Constant 2 $00000001
Addr : 11E6:             EC  : Math Op +     
Addr : 11E7:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 11E9:             E8  : Math Op &     
Addr : 11EA:             4D  : Variable Operation Global Offset - 3 Write
102                        if rxtx_mode & %1000
Addr : 11EB:             5C  : Variable Operation Global Offset - 7 Read
Addr : 11EC:          37 02  : Constant Mask Y=2 00000008 8
Addr : 11EE:             E8  : Math Op &     
Addr : 11EF: JZ Label0005
Addr : 11EF:          0A 03  : jz Address = 11F4 3
103                          rx
Addr : 11F1:             01  : Drop Anchor   
Addr : 11F2:          05 05  : Call Sub 5    
Addr : 11F4: Label0005
Addr : 11F4: Label0006
Addr : 11F4:             32  : Return        
|===========================================================================|
Spin Block rx with 0 Parameters and 0 Extra Stack Longs. Method 5
PUB rx : rxbyte

Local Parameter DBASE:0000 - rxbyte
|===========================================================================|
110                        repeat while (rxbyte := rxcheck) < 0
Addr : 11F5: Label0002
Addr : 11F5:             00  : Drop Anchor Push 
Addr : 11F6:          05 07  : Call Sub 7    
Addr : 11F8:          62 80  : Variable Operation Local Offset - 0 Assign Write Push
Addr : 11FA:             35  : Constant 1 $00000000
Addr : 11FB:             F9  : Math Op <     
Addr : 11FC: JZ Label0004
Addr : 11FC:          0A 02  : jz Address = 1200 2
Addr : 11FE: Label0003
Addr : 11FE: JMP Label0002
Addr : 11FE:          04 75  : Jmp 11F5 -11  
Addr : 1200: Label0004
Addr : 1200:             32  : Return        
|===========================================================================|
Spin Block rxflush with 0 Parameters and 0 Extra Stack Longs. Method 6
PUB rxflush

Local Parameter DBASE:0000 - Result
|===========================================================================|
116                        repeat while rxcheck => 0
Addr : 1201: Label0002
Addr : 1201:             00  : Drop Anchor Push 
Addr : 1202:          05 07  : Call Sub 7    
Addr : 1204:             35  : Constant 1 $00000000
Addr : 1205:             FE  : Math Op =>    
Addr : 1206: JZ Label0004
Addr : 1206:          0A 02  : jz Address = 120A 2
Addr : 1208: Label0003
Addr : 1208: JMP Label0002
Addr : 1208:          04 77  : Jmp 1201 -9   
Addr : 120A: Label0004
Addr : 120A:             32  : Return        
|===========================================================================|
Spin Block rxcheck with 0 Parameters and 0 Extra Stack Longs. Method 7
PUB rxcheck : rxbyte

Local Parameter DBASE:0000 - rxbyte
|===========================================================================|
123                        rxbyte--
Addr : 120B:          62 3E  : Variable Operation Local Offset - 0 Assign VAR-- post-dec Long
124                        if rx_tail <> rx_head
Addr : 120D:             48  : Variable Operation Global Offset - 2 Read
Addr : 120E:             44  : Variable Operation Global Offset - 1 Read
Addr : 120F:             FB  : Math Op <>    
Addr : 1210: JZ Label0002
Addr : 1210:          0A 0B  : jz Address = 121D 11
125                          rxbyte := rx_buffer[rx_tail]
Addr : 1212:             48  : Variable Operation Global Offset - 2 Read
Addr : 1213:          98 24  : Memory Op Byte VBASE + POP Index READ Address = 0024
Addr : 1215:             61  : Variable Operation Local Offset - 0 Write
126                          rx_tail := (rx_tail + 1) & $F
Addr : 1216:             48  : Variable Operation Global Offset - 2 Read
Addr : 1217:             36  : Constant 2 $00000001
Addr : 1218:             EC  : Math Op +     
Addr : 1219:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 121B:             E8  : Math Op &     
Addr : 121C:             49  : Variable Operation Global Offset - 2 Write
Addr : 121D: Label0002
Addr : 121D: Label0003
Addr : 121D:             32  : Return        
|===========================================================================|
Spin Block rxtime with 1 Parameters and 1 Extra Stack Longs. Method 8
PUB rxtime(ms) : rxbyte | t

Local Parameter DBASE:0000 - rxbyte
Local Parameter DBASE:0004 - ms
Local Variable  DBASE:0008 - t
|===========================================================================|
133                        t := cnt
Addr : 121E:          3F 91  : Register op CNT Read
Addr : 1220:             69  : Variable Operation Local Offset - 2 Write
Addr : 1221: Label0002
134                        repeat until (rxbyte := rxcheck) => 0 or (cnt - t) / (clkfreq / 1000) > ms
Addr : 1221:             00  : Drop Anchor Push 
Addr : 1222:          05 07  : Call Sub 7    
Addr : 1224:          62 80  : Variable Operation Local Offset - 0 Assign Write Push
Addr : 1226:             35  : Constant 1 $00000000
Addr : 1227:             FE  : Math Op =>    
Addr : 1228:          3F 91  : Register op CNT Read
Addr : 122A:             68  : Variable Operation Local Offset - 2 Read
Addr : 122B:             ED  : Math Op -     
Addr : 122C:             35  : Constant 1 $00000000
Addr : 122D:             C0  : Memory Op Long POP Address READ 
Addr : 122E:       39 03 E8  : Constant 2 Bytes - 03 E8 - $000003E8 1000
Addr : 1231:             F6  : Math Op /     
Addr : 1232:             F6  : Math Op /     
Addr : 1233:             64  : Variable Operation Local Offset - 1 Read
Addr : 1234:             FA  : Math Op >     
Addr : 1235:             F2  : Math Op OR    
Addr : 1236: JNZ Label0004
Addr : 1236:          0B 02  : jnz Address = 123A 2
Addr : 1238: Label0003
Addr : 1238: JMP Label0002
Addr : 1238:          04 67  : Jmp 1221 -25  
Addr : 123A: Label0004
Addr : 123A:             32  : Return        
|===========================================================================|
Spin Block puts with 1 Parameters and 0 Extra Stack Longs. Method 9
PUB puts(s)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - s
|===========================================================================|
137                        str(s)
Addr : 123B:             01  : Drop Anchor   
Addr : 123C:             64  : Variable Operation Local Offset - 1 Read
Addr : 123D:          05 0D  : Call Sub 13   
Addr : 123F:             32  : Return        
|===========================================================================|
Spin Block crlf with 0 Parameters and 0 Extra Stack Longs. Method 10
PUB crlf

Local Parameter DBASE:0000 - Result
|===========================================================================|
140                        tx(13)
Addr : 1240:             01  : Drop Anchor   
Addr : 1241:          38 0D  : Constant 1 Bytes - 0D - $0000000D 13
Addr : 1243:          05 04  : Call Sub 4    
141                        tx(10)
Addr : 1245:             01  : Drop Anchor   
Addr : 1246:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 1248:          05 04  : Call Sub 4    
Addr : 124A:             32  : Return        
|===========================================================================|
Spin Block getc with 0 Parameters and 0 Extra Stack Longs. Method 11
PUB getc

Local Parameter DBASE:0000 - Result
|===========================================================================|
144                        return rx
Addr : 124B:             00  : Drop Anchor Push 
Addr : 124C:          05 05  : Call Sub 5    
Addr : 124E:             33  : Return value  
Addr : 124F: Data : 32                       2
|===========================================================================|
Spin Block putc with 1 Parameters and 0 Extra Stack Longs. Method 12
PUB putc(c)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - c
|===========================================================================|
147                        tx(c)
Addr : 1250:             01  : Drop Anchor   
Addr : 1251:             64  : Variable Operation Local Offset - 1 Read
Addr : 1252:          05 04  : Call Sub 4    
Addr : 1254:             32  : Return        
|===========================================================================|
Spin Block str with 1 Parameters and 0 Extra Stack Longs. Method 13
PUB str(stringptr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - stringptr
|===========================================================================|
153                        repeat strsize(stringptr)
Addr : 1255:             64  : Variable Operation Local Offset - 1 Read
Addr : 1256:             16  : StrSize(String)
Addr : 1257: TJZ Label0004
Addr : 1257:          08 08  : tjz Address = 1261 8
Addr : 1259: Label0002
154                          tx(byte[stringptr++])
Addr : 1259:             01  : Drop Anchor   
Addr : 125A:          66 AE  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long Push
Addr : 125C:             80  : Memory Op Byte POP Address READ 
Addr : 125D:          05 04  : Call Sub 4    
Addr : 125F: Label0003
Addr : 125F: DJNZ Label0002
Addr : 125F:          09 78  : djnz Address = 1259 -8
Addr : 1261: Label0004
Addr : 1261:             32  : Return        
|===========================================================================|
Spin Block getstr with 1 Parameters and 2 Extra Stack Longs. Method 14
PUB getstr(stringptr) | index, ch

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - stringptr
Local Variable  DBASE:0008 - index
Local Variable  DBASE:000C - ch
|===========================================================================|
158                          index~
Addr : 1262:          6A 18  : Variable Operation Local Offset - 2 Assign VAR~ Post-clear
Addr : 1264: Label0004
159                          repeat until ch==13
Addr : 1264:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1265:          38 0D  : Constant 1 Bytes - 0D - $0000000D 13
Addr : 1267:             FC  : Math Op ==    
Addr : 1268: JNZ Label0006
Addr : 1268:          0B 25  : jnz Address = 128F 37
160                            tx(ch:=rx)
Addr : 126A:             01  : Drop Anchor   
Addr : 126B:             00  : Drop Anchor Push 
Addr : 126C:          05 05  : Call Sub 5    
Addr : 126E:          6E 80  : Variable Operation Local Offset - 3 Assign Write Push
Addr : 1270:          05 04  : Call Sub 4    
161                            if ch<>8
Addr : 1272:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1273:          37 02  : Constant Mask Y=2 00000008 8
Addr : 1275:             FB  : Math Op <>    
Addr : 1276: JZ Label0007
Addr : 1276:          0A 07  : jz Address = 127F 7
162                              byte[stringptr][index++] := ch
Addr : 1278:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1279:             64  : Variable Operation Local Offset - 1 Read
Addr : 127A:          6A AE  : Variable Operation Local Offset - 2 Assign VAR++ post inc Long Push
Addr : 127C:             91  : Memory Op Byte POP Address POP Index WRITE 
Addr : 127D: JMP Label0008
Addr : 127D:          04 0E  : Jmp 128D 14   
Addr : 127F: Label0007
164                              if index>0
Addr : 127F:             68  : Variable Operation Local Offset - 2 Read
Addr : 1280:             35  : Constant 1 $00000000
Addr : 1281:             FA  : Math Op >     
Addr : 1282: JZ Label000A
Addr : 1282:          0A 04  : jz Address = 1288 4
165                                index--
Addr : 1284:          6A 3E  : Variable Operation Local Offset - 2 Assign VAR-- post-dec Long
Addr : 1286: JMP Label000B
Addr : 1286:          04 05  : Jmp 128D 5    
Addr : 1288: Label000A
167                                tx(32)
Addr : 1288:             01  : Drop Anchor   
Addr : 1289:          37 04  : Constant Mask Y=4 00000020 32
Addr : 128B:          05 04  : Call Sub 4    
Addr : 128D: Label000C
Addr : 128D: Label000B
Addr : 128D: Label0009
Addr : 128D: Label0008
Addr : 128D: Label0005
Addr : 128D: JMP Label0004
Addr : 128D:          04 55  : Jmp 1264 -43  
Addr : 128F: Label0006
168                          byte[stringptr][--index]~
Addr : 128F:             64  : Variable Operation Local Offset - 1 Read
Addr : 1290:          6A B6  : Variable Operation Local Offset - 2 Assign --VAR pre-dec Long Push
Addr : 1292:          92 18  : Memory Op Byte POP Address POP Index ASSIGN VAR~ Post-clear
Addr : 1294:             32  : Return        
|===========================================================================|
Spin Block dec with 1 Parameters and 1 Extra Stack Longs. Method 15
PUB dec(value) | i

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - value
Local Variable  DBASE:0008 - i
|===========================================================================|
174                        if value < 0
Addr : 1295:             64  : Variable Operation Local Offset - 1 Read
Addr : 1296:             35  : Constant 1 $00000000
Addr : 1297:             F9  : Math Op <     
Addr : 1298: JZ Label0002
Addr : 1298:          0A 07  : jz Address = 12A1 7
175                          -value
Addr : 129A:          66 46  : Variable Operation Local Offset - 1 Assign LongMathop -
176                          tx("-")
Addr : 129C:             01  : Drop Anchor   
Addr : 129D:          38 2D  : Constant 1 Bytes - 2D - $0000002D 45
Addr : 129F:          05 04  : Call Sub 4    
Addr : 12A1: Label0002
Addr : 12A1: Label0003
178                        i := 1_000_000_000
Addr : 12A1: 3B 3B 9A CA 00  : Constant 4 Bytes - 3B 9A CA 00 - $3B9ACA00 1000000000
Addr : 12A6:             69  : Variable Operation Local Offset - 2 Write
180                        repeat 10
Addr : 12A7:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 12A9: TJZ Label0006
Addr : 12A9:          08 27  : tjz Address = 12D2 39
Addr : 12AB: Label0004
181                          if value => i
Addr : 12AB:             64  : Variable Operation Local Offset - 1 Read
Addr : 12AC:             68  : Variable Operation Local Offset - 2 Read
Addr : 12AD:             FE  : Math Op =>    
Addr : 12AE: JZ Label0007
Addr : 12AE:          0A 10  : jz Address = 12C0 16
182                            tx(value / i + "0")
Addr : 12B0:             01  : Drop Anchor   
Addr : 12B1:             64  : Variable Operation Local Offset - 1 Read
Addr : 12B2:             68  : Variable Operation Local Offset - 2 Read
Addr : 12B3:             F6  : Math Op /     
Addr : 12B4:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 12B6:             EC  : Math Op +     
Addr : 12B7:          05 04  : Call Sub 4    
183                            value //= i
Addr : 12B9:             68  : Variable Operation Local Offset - 2 Read
Addr : 12BA:          66 57  : Variable Operation Local Offset - 1 Assign LongMathop //
184                            result~~
Addr : 12BC:          62 1C  : Variable Operation Local Offset - 0 Assign VAR~~ Post-set
Addr : 12BE: JMP Label0008
Addr : 12BE:          04 0C  : Jmp 12CC 12   
Addr : 12C0: Label0007
185                          elseif result or i == 1
Addr : 12C0:             60  : Variable Operation Local Offset - 0 Read
Addr : 12C1:             68  : Variable Operation Local Offset - 2 Read
Addr : 12C2:             36  : Constant 2 $00000001
Addr : 12C3:             FC  : Math Op ==    
Addr : 12C4:             F2  : Math Op OR    
Addr : 12C5: JZ Label0009
Addr : 12C5:          0A 05  : jz Address = 12CC 5
186                            tx("0")
Addr : 12C7:             01  : Drop Anchor   
Addr : 12C8:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 12CA:          05 04  : Call Sub 4    
Addr : 12CC: Label0009
Addr : 12CC: Label0008
187                          i /= 10
Addr : 12CC:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 12CE:          6A 56  : Variable Operation Local Offset - 2 Assign LongMathop /
Addr : 12D0: Label0005
Addr : 12D0: DJNZ Label0004
Addr : 12D0:          09 59  : djnz Address = 12AB -39
Addr : 12D2: Label0006
Addr : 12D2:             32  : Return        
|===========================================================================|
Spin Block GetDec with 0 Parameters and 11 Extra Stack Longs. Method 16
PUB GetDec : value | tempstr[11]

Local Parameter DBASE:0000 - value
Local Variable  DBASE:0004 - tempstr
|===========================================================================|
195                          GetStr(@tempstr)
Addr : 12D3:             01  : Drop Anchor   
Addr : 12D4:             67  : Variable Operation Local Offset - 1 Address
Addr : 12D5:          05 0E  : Call Sub 14   
196                          value := StrToDec(@tempstr)    
Addr : 12D7:             00  : Drop Anchor Push 
Addr : 12D8:             67  : Variable Operation Local Offset - 1 Address
Addr : 12D9:          05 11  : Call Sub 17   
Addr : 12DB:             61  : Variable Operation Local Offset - 0 Write
Addr : 12DC:             32  : Return        
|===========================================================================|
Spin Block StrToDec with 1 Parameters and 3 Extra Stack Longs. Method 17
PUB StrToDec(stringptr) : value | char, index, multiply

Local Parameter DBASE:0000 - value
Local Parameter DBASE:0004 - stringptr
Local Variable  DBASE:0008 - char
Local Variable  DBASE:000C - index
Local Variable  DBASE:0010 - multiply
|===========================================================================|
202                          value := index := 0
Addr : 12DD:             35  : Constant 1 $00000000
Addr : 12DE:          6E 80  : Variable Operation Local Offset - 3 Assign Write Push
Addr : 12E0:             61  : Variable Operation Local Offset - 0 Write
Addr : 12E1: Label0004
203                          repeat until ((char := byte[stringptr][index++]) == 0)
Addr : 12E1:             64  : Variable Operation Local Offset - 1 Read
Addr : 12E2:          6E AE  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long Push
Addr : 12E4:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 12E5:          6A 80  : Variable Operation Local Offset - 2 Assign Write Push
Addr : 12E7:             35  : Constant 1 $00000000
Addr : 12E8:             FC  : Math Op ==    
Addr : 12E9: JNZ Label0006
Addr : 12E9:          0B 17  : jnz Address = 1302 23
204                             if char => "0" and char =< "9"
Addr : 12EB:             68  : Variable Operation Local Offset - 2 Read
Addr : 12EC:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 12EE:             FE  : Math Op =>    
Addr : 12EF:             68  : Variable Operation Local Offset - 2 Read
Addr : 12F0:          38 39  : Constant 1 Bytes - 39 - $00000039 57
Addr : 12F2:             FD  : Math Op =<    
Addr : 12F3:             F0  : Math Op AND   
Addr : 12F4: JZ Label0007
Addr : 12F4:          0A 0A  : jz Address = 1300 10
205                                value := value * 10 + (char - "0")
Addr : 12F6:             60  : Variable Operation Local Offset - 0 Read
Addr : 12F7:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 12F9:             F4  : Math Op *     
Addr : 12FA:             68  : Variable Operation Local Offset - 2 Read
Addr : 12FB:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 12FD:             ED  : Math Op -     
Addr : 12FE:             EC  : Math Op +     
Addr : 12FF:             61  : Variable Operation Local Offset - 0 Write
Addr : 1300: Label0007
Addr : 1300: Label0008
Addr : 1300: Label0005
Addr : 1300: JMP Label0004
Addr : 1300:          04 5F  : Jmp 12E1 -33  
Addr : 1302: Label0006
206                          if byte[stringptr] == "-"
Addr : 1302:             64  : Variable Operation Local Offset - 1 Read
Addr : 1303:             80  : Memory Op Byte POP Address READ 
Addr : 1304:          38 2D  : Constant 1 Bytes - 2D - $0000002D 45
Addr : 1306:             FC  : Math Op ==    
Addr : 1307: JZ Label0009
Addr : 1307:          0A 03  : jz Address = 130C 3
207                             value := - value
Addr : 1309:             60  : Variable Operation Local Offset - 0 Read
Addr : 130A:             E6  : Math Op -     
Addr : 130B:             61  : Variable Operation Local Offset - 0 Write
Addr : 130C: Label0009
Addr : 130C: Label000A
Addr : 130C:             32  : Return        
|===========================================================================|
Spin Block bin with 2 Parameters and 0 Extra Stack Longs. Method 18
PUB bin(value, digits)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - value
Local Parameter DBASE:0008 - digits
|===========================================================================|
213                        value <<= 32 - digits
Addr : 130D:          37 04  : Constant Mask Y=4 00000020 32
Addr : 130F:             68  : Variable Operation Local Offset - 2 Read
Addr : 1310:             ED  : Math Op -     
Addr : 1311:          66 43  : Variable Operation Local Offset - 1 Assign ByteMathop <<
214                        repeat digits
Addr : 1313:             68  : Variable Operation Local Offset - 2 Read
Addr : 1314: TJZ Label0004
Addr : 1314:          08 0D  : tjz Address = 1323 13
Addr : 1316: Label0002
215                          tx((value <-= 1) & 1 + "0")
Addr : 1316:             01  : Drop Anchor   
Addr : 1317:             36  : Constant 2 $00000001
Addr : 1318:          66 C1  : Variable Operation Local Offset - 1 Assign BitMathop -< Push
Addr : 131A:             36  : Constant 2 $00000001
Addr : 131B:             E8  : Math Op &     
Addr : 131C:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 131E:             EC  : Math Op +     
Addr : 131F:          05 04  : Call Sub 4    
Addr : 1321: Label0003
Addr : 1321: DJNZ Label0002
Addr : 1321:          09 73  : djnz Address = 1316 -13
Addr : 1323: Label0004
Addr : 1323:             32  : Return        
|===========================================================================|
Spin Block GetBin with 0 Parameters and 11 Extra Stack Longs. Method 19
PUB GetBin : value | tempstr[11]

Local Parameter DBASE:0000 - value
Local Variable  DBASE:0004 - tempstr
|===========================================================================|
222                        GetStr(@tempstr)
Addr : 1324:             01  : Drop Anchor   
Addr : 1325:             67  : Variable Operation Local Offset - 1 Address
Addr : 1326:          05 0E  : Call Sub 14   
223                        value := StrToBin(@tempstr)    
Addr : 1328:             00  : Drop Anchor Push 
Addr : 1329:             67  : Variable Operation Local Offset - 1 Address
Addr : 132A:          05 14  : Call Sub 20   
Addr : 132C:             61  : Variable Operation Local Offset - 0 Write
Addr : 132D:             32  : Return        
|===========================================================================|
Spin Block StrToBin with 1 Parameters and 2 Extra Stack Longs. Method 20
PUB StrToBin(stringptr) : value | char, index

Local Parameter DBASE:0000 - value
Local Parameter DBASE:0004 - stringptr
Local Variable  DBASE:0008 - char
Local Variable  DBASE:000C - index
|===========================================================================|
229                        value := index := 0
Addr : 132E:             35  : Constant 1 $00000000
Addr : 132F:          6E 80  : Variable Operation Local Offset - 3 Assign Write Push
Addr : 1331:             61  : Variable Operation Local Offset - 0 Write
Addr : 1332: Label0002
230                        repeat until ((char := byte[stringptr][index++]) == 0)
Addr : 1332:             64  : Variable Operation Local Offset - 1 Read
Addr : 1333:          6E AE  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long Push
Addr : 1335:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 1336:          6A 80  : Variable Operation Local Offset - 2 Assign Write Push
Addr : 1338:             35  : Constant 1 $00000000
Addr : 1339:             FC  : Math Op ==    
Addr : 133A: JNZ Label0004
Addr : 133A:          0B 17  : jnz Address = 1353 23
231                           if char => "0" and char =< "1"
Addr : 133C:             68  : Variable Operation Local Offset - 2 Read
Addr : 133D:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 133F:             FE  : Math Op =>    
Addr : 1340:             68  : Variable Operation Local Offset - 2 Read
Addr : 1341:          38 31  : Constant 1 Bytes - 31 - $00000031 49
Addr : 1343:             FD  : Math Op =<    
Addr : 1344:             F0  : Math Op AND   
Addr : 1345: JZ Label0005
Addr : 1345:          0A 0A  : jz Address = 1351 10
232                              value := value * 2 + (char - "0")
Addr : 1347:             60  : Variable Operation Local Offset - 0 Read
Addr : 1348:          37 00  : Constant Mask Y=0 00000002 2
Addr : 134A:             F4  : Math Op *     
Addr : 134B:             68  : Variable Operation Local Offset - 2 Read
Addr : 134C:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 134E:             ED  : Math Op -     
Addr : 134F:             EC  : Math Op +     
Addr : 1350:             61  : Variable Operation Local Offset - 0 Write
Addr : 1351: Label0005
Addr : 1351: Label0006
Addr : 1351: Label0003
Addr : 1351: JMP Label0002
Addr : 1351:          04 5F  : Jmp 1332 -33  
Addr : 1353: Label0004
233                        if byte[stringptr] == "-"
Addr : 1353:             64  : Variable Operation Local Offset - 1 Read
Addr : 1354:             80  : Memory Op Byte POP Address READ 
Addr : 1355:          38 2D  : Constant 1 Bytes - 2D - $0000002D 45
Addr : 1357:             FC  : Math Op ==    
Addr : 1358: JZ Label0007
Addr : 1358:          0A 03  : jz Address = 135D 3
234                           value := - value
Addr : 135A:             60  : Variable Operation Local Offset - 0 Read
Addr : 135B:             E6  : Math Op -     
Addr : 135C:             61  : Variable Operation Local Offset - 0 Write
Addr : 135D: Label0007
Addr : 135D: Label0008
Addr : 135D:             32  : Return        
|===========================================================================|
Spin Block hex with 2 Parameters and 0 Extra Stack Longs. Method 21
PUB hex(value, digits)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - value
Local Parameter DBASE:0008 - digits
|===========================================================================|
240                        value <<= (8 - digits) << 2
Addr : 135E:          37 02  : Constant Mask Y=2 00000008 8
Addr : 1360:             68  : Variable Operation Local Offset - 2 Read
Addr : 1361:             ED  : Math Op -     
Addr : 1362:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1364:             E3  : Math Op <<    
Addr : 1365:          66 43  : Variable Operation Local Offset - 1 Assign ByteMathop <<
241                        repeat digits
Addr : 1367:             68  : Variable Operation Local Offset - 2 Read
Addr : 1368: TJZ Label0004
Addr : 1368:          08 1B  : tjz Address = 1385 27
Addr : 136A: Label0002
242                          tx(lookupz((value <-= 4) & $F : "0".."9", "A".."F"))
Addr : 136A:             01  : Drop Anchor   
Addr : 136B:             35  : Constant 1 $00000000
Addr : 136C: Constant Address of Label0005
Addr : 136C:       39 03 8D  : Constant 2 Bytes - 03 8D - $0000038D 909
Addr : 136F:          37 01  : Constant Mask Y=1 00000004 4
Addr : 1371:          66 C1  : Variable Operation Local Offset - 1 Assign BitMathop -< Push
Addr : 1373:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 1375:             E8  : Math Op &     
Addr : 1376:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 1378:          38 39  : Constant 1 Bytes - 39 - $00000039 57
Addr : 137A:             12  : Range LookUp  
Addr : 137B:          38 41  : Constant 1 Bytes - 41 - $00000041 65
Addr : 137D:          38 46  : Constant 1 Bytes - 46 - $00000046 70
Addr : 137F:             12  : Range LookUp  
Addr : 1380:             0F  : Lookdone      
Addr : 1381: Label0005
Addr : 1381:          05 04  : Call Sub 4    
Addr : 1383: Label0003
Addr : 1383: DJNZ Label0002
Addr : 1383:          09 65  : djnz Address = 136A -27
Addr : 1385: Label0004
Addr : 1385:             32  : Return        
|===========================================================================|
Spin Block GetHex with 0 Parameters and 11 Extra Stack Longs. Method 22
PUB GetHex : value | tempstr[11]

Local Parameter DBASE:0000 - value
Local Variable  DBASE:0004 - tempstr
|===========================================================================|
249                          GetStr(@tempstr)
Addr : 1386:             01  : Drop Anchor   
Addr : 1387:             67  : Variable Operation Local Offset - 1 Address
Addr : 1388:          05 0E  : Call Sub 14   
250                          value := StrToHex(@tempstr)    
Addr : 138A:             00  : Drop Anchor Push 
Addr : 138B:             67  : Variable Operation Local Offset - 1 Address
Addr : 138C:          05 17  : Call Sub 23   
Addr : 138E:             61  : Variable Operation Local Offset - 0 Write
Addr : 138F:             32  : Return        
|===========================================================================|
Spin Block StrToHex with 1 Parameters and 2 Extra Stack Longs. Method 23
PUB StrToHex(stringptr) : value | char, index

Local Parameter DBASE:0000 - value
Local Parameter DBASE:0004 - stringptr
Local Variable  DBASE:0008 - char
Local Variable  DBASE:000C - index
|===========================================================================|
256                          value := index := 0
Addr : 1390:             35  : Constant 1 $00000000
Addr : 1391:          6E 80  : Variable Operation Local Offset - 3 Assign Write Push
Addr : 1393:             61  : Variable Operation Local Offset - 0 Write
Addr : 1394: Label0004
257                          repeat until ((char := byte[stringptr][index++]) == 0)
Addr : 1394:             64  : Variable Operation Local Offset - 1 Read
Addr : 1395:          6E AE  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long Push
Addr : 1397:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 1398:          6A 80  : Variable Operation Local Offset - 2 Assign Write Push
Addr : 139A:             35  : Constant 1 $00000000
Addr : 139B:             FC  : Math Op ==    
Addr : 139C: JNZ Label0006
Addr : 139C:       0B 80 4C  : jnz Address = 13EB 76
258                             if (char => "0" and char =< "9")
Addr : 139F:             68  : Variable Operation Local Offset - 2 Read
Addr : 13A0:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 13A2:             FE  : Math Op =>    
Addr : 13A3:             68  : Variable Operation Local Offset - 2 Read
Addr : 13A4:          38 39  : Constant 1 Bytes - 39 - $00000039 57
Addr : 13A6:             FD  : Math Op =<    
Addr : 13A7:             F0  : Math Op AND   
Addr : 13A8: JZ Label0007
Addr : 13A8:          0A 0C  : jz Address = 13B6 12
259                                value := value * 16 + (char - "0")
Addr : 13AA:             60  : Variable Operation Local Offset - 0 Read
Addr : 13AB:          37 03  : Constant Mask Y=3 00000010 16
Addr : 13AD:             F4  : Math Op *     
Addr : 13AE:             68  : Variable Operation Local Offset - 2 Read
Addr : 13AF:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 13B1:             ED  : Math Op -     
Addr : 13B2:             EC  : Math Op +     
Addr : 13B3:             61  : Variable Operation Local Offset - 0 Write
Addr : 13B4: JMP Label0008
Addr : 13B4:          04 32  : Jmp 13E8 50   
Addr : 13B6: Label0007
260                             elseif (char => "A" and char =< "F")
Addr : 13B6:             68  : Variable Operation Local Offset - 2 Read
Addr : 13B7:          38 41  : Constant 1 Bytes - 41 - $00000041 65
Addr : 13B9:             FE  : Math Op =>    
Addr : 13BA:             68  : Variable Operation Local Offset - 2 Read
Addr : 13BB:          38 46  : Constant 1 Bytes - 46 - $00000046 70
Addr : 13BD:             FD  : Math Op =<    
Addr : 13BE:             F0  : Math Op AND   
Addr : 13BF: JZ Label0009
Addr : 13BF:          0A 0F  : jz Address = 13D0 15
261                                value := value * 16 + (10 + char - "A")
Addr : 13C1:             60  : Variable Operation Local Offset - 0 Read
Addr : 13C2:          37 03  : Constant Mask Y=3 00000010 16
Addr : 13C4:             F4  : Math Op *     
Addr : 13C5:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 13C7:             68  : Variable Operation Local Offset - 2 Read
Addr : 13C8:             EC  : Math Op +     
Addr : 13C9:          38 41  : Constant 1 Bytes - 41 - $00000041 65
Addr : 13CB:             ED  : Math Op -     
Addr : 13CC:             EC  : Math Op +     
Addr : 13CD:             61  : Variable Operation Local Offset - 0 Write
Addr : 13CE: JMP Label0008
Addr : 13CE:          04 18  : Jmp 13E8 24   
Addr : 13D0: Label0009
262                             elseif(char => "a" and char =< "f")   
Addr : 13D0:             68  : Variable Operation Local Offset - 2 Read
Addr : 13D1:          38 61  : Constant 1 Bytes - 61 - $00000061 97
Addr : 13D3:             FE  : Math Op =>    
Addr : 13D4:             68  : Variable Operation Local Offset - 2 Read
Addr : 13D5:          38 66  : Constant 1 Bytes - 66 - $00000066 102
Addr : 13D7:             FD  : Math Op =<    
Addr : 13D8:             F0  : Math Op AND   
Addr : 13D9: JZ Label000A
Addr : 13D9:          0A 0D  : jz Address = 13E8 13
263                                value := value * 16 + (10 + char - "a")
Addr : 13DB:             60  : Variable Operation Local Offset - 0 Read
Addr : 13DC:          37 03  : Constant Mask Y=3 00000010 16
Addr : 13DE:             F4  : Math Op *     
Addr : 13DF:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 13E1:             68  : Variable Operation Local Offset - 2 Read
Addr : 13E2:             EC  : Math Op +     
Addr : 13E3:          38 61  : Constant 1 Bytes - 61 - $00000061 97
Addr : 13E5:             ED  : Math Op -     
Addr : 13E6:             EC  : Math Op +     
Addr : 13E7:             61  : Variable Operation Local Offset - 0 Write
Addr : 13E8: Label000A
Addr : 13E8: Label0008
Addr : 13E8: Label0005
Addr : 13E8: JMP Label0004
Addr : 13E8:       04 FF A9  : Jmp 1394 -87  
Addr : 13EB: Label0006
264                          if byte[stringptr] == "-"
Addr : 13EB:             64  : Variable Operation Local Offset - 1 Read
Addr : 13EC:             80  : Memory Op Byte POP Address READ 
Addr : 13ED:          38 2D  : Constant 1 Bytes - 2D - $0000002D 45
Addr : 13EF:             FC  : Math Op ==    
Addr : 13F0: JZ Label000B
Addr : 13F0:          0A 03  : jz Address = 13F5 3
265                             value := - value
Addr : 13F2:             60  : Variable Operation Local Offset - 0 Read
Addr : 13F3:             E6  : Math Op -     
Addr : 13F4:             61  : Variable Operation Local Offset - 0 Write
Addr : 13F5: Label000B
Addr : 13F5: Label000C
Addr : 13F5:             32  : Return        
|===========================================================================|
Object fsrwFemto_rr001
Object Base is 13F8
|===========================================================================|
Object Constants
|===========================================================================|
|===========================================================================|
VBASE Global Variables
|===========================================================================|
VBASE : 0000 LONG Size 0004 Variable fclust
VBASE : 0004 LONG Size 0004 Variable filesize
VBASE : 0008 LONG Size 0004 Variable floc
VBASE : 000C LONG Size 0004 Variable frem
VBASE : 0010 LONG Size 0004 Variable bufat
VBASE : 0014 LONG Size 0004 Variable bufend
VBASE : 0018 LONG Size 0004 Variable writelink
VBASE : 001C LONG Size 0004 Variable direntry
VBASE : 0020 LONG Size 0004 Variable fatptr
VBASE : 0024 LONG Size 0004 Variable rootdir
VBASE : 0028 LONG Size 0004 Variable rootdirend
VBASE : 002C LONG Size 0004 Variable dataregion
VBASE : 0030 LONG Size 0004 Variable clustershift
VBASE : 0034 LONG Size 0004 Variable fat1
VBASE : 0038 LONG Size 0004 Variable totclusters
VBASE : 003C LONG Size 0004 Variable sectorsperfat
VBASE : 0040 LONG Size 0004 Variable lastread
VBASE : 0044 LONG Size 0004 Variable dirty
VBASE : 0048 BYTE Size 0200 Variable buf
VBASE : 0248 BYTE Size 0200 Variable buf2
VBASE : 0448 BYTE Size 000B Variable padname
|===========================================================================|
|===========================================================================|
Spin Block startSD with 1 Parameters and 0 Extra Stack Longs. Method 1
pub startSD(ioControl)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - ioControl
|===========================================================================|
83                         return ldr.start(ioControl)
Addr : 14A8:             00  : Drop Anchor Push 
Addr : 14A9:             64  : Variable Operation Local Offset - 1 Read
Addr : 14AA:       06 2B 09  : Call Obj.Sub 43 9
Addr : 14AD:             33  : Return value  
Addr : 14AE: Data : 32                       2
|===========================================================================|
Spin Block stop with 0 Parameters and 0 Extra Stack Longs. Method 2
pub stop

Local Parameter DBASE:0000 - Result
|===========================================================================|
86                         return ldr.stop
Addr : 14AF:             00  : Drop Anchor Push 
Addr : 14B0:       06 2B 0A  : Call Obj.Sub 43 10
Addr : 14B3:             33  : Return value  
Addr : 14B4: Data : 32                       2
|===========================================================================|
Spin Block checkPresence with 1 Parameters and 0 Extra Stack Longs. Method 3
pub checkPresence(address)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - address
|===========================================================================|
89                         return ldr.checkPresence(address)
Addr : 14B5:             00  : Drop Anchor Push 
Addr : 14B6:             64  : Variable Operation Local Offset - 1 Read
Addr : 14B7:       06 2B 01  : Call Obj.Sub 43 1
Addr : 14BA:             33  : Return value  
Addr : 14BB: Data : 32                       2
|===========================================================================|
Spin Block writeWait with 1 Parameters and 1 Extra Stack Longs. Method 4
pub writeWait(address) | startTime

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - address
Local Variable  DBASE:0008 - startTime
|===========================================================================|
92                         return ldr.writeWait(address)
Addr : 14BC:             00  : Drop Anchor Push 
Addr : 14BD:             64  : Variable Operation Local Offset - 1 Read
Addr : 14BE:       06 2B 02  : Call Obj.Sub 43 2
Addr : 14C1:             33  : Return value  
Addr : 14C2: Data : 32                       2
|===========================================================================|
Spin Block initSDCard with 4 Parameters and 0 Extra Stack Longs. Method 5
pub initSDCard(DO, Clk, DI, CS)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - DO
Local Parameter DBASE:0008 - Clk
Local Parameter DBASE:000C - DI
Local Parameter DBASE:0010 - CS
|===========================================================================|
95                         return ldr.initSDCard(DO, Clk, DI, CS)
Addr : 14C3:             00  : Drop Anchor Push 
Addr : 14C4:             64  : Variable Operation Local Offset - 1 Read
Addr : 14C5:             68  : Variable Operation Local Offset - 2 Read
Addr : 14C6:             6C  : Variable Operation Local Offset - 3 Read
Addr : 14C7:             70  : Variable Operation Local Offset - 4 Read
Addr : 14C8:       06 2B 04  : Call Obj.Sub 43 4
Addr : 14CB:             33  : Return value  
Addr : 14CC: Data : 32                       2
|===========================================================================|
Spin Block stopSDCard with 0 Parameters and 0 Extra Stack Longs. Method 6
pub stopSDCard

Local Parameter DBASE:0000 - Result
|===========================================================================|
98                         return ldr.stopSDCard
Addr : 14CD:             00  : Drop Anchor Push 
Addr : 14CE:       06 2B 05  : Call Obj.Sub 43 5
Addr : 14D1:             33  : Return value  
Addr : 14D2: Data : 32                       2
|===========================================================================|
Spin Block bootSDCard with 0 Parameters and 0 Extra Stack Longs. Method 7
pub bootSDCard                    ' Execute up to 32K from current file

Local Parameter DBASE:0000 - Result
|===========================================================================|
101                         return ldr.bootSDCard(datablock, filesize <# $8000)
Addr : 14D3:             00  : Drop Anchor Push 
Addr : 14D4:             00  : Drop Anchor Push 
Addr : 14D5:          05 26  : Call Sub 38   
Addr : 14D7:             44  : Variable Operation Global Offset - 1 Read
Addr : 14D8:          37 0E  : Constant Mask Y=14 00008000 32768
Addr : 14DA:             E5  : Math Op <#    
Addr : 14DB:       06 2B 08  : Call Obj.Sub 43 8
Addr : 14DE:             33  : Return value  
Addr : 14DF: Data : 32                       2
|===========================================================================|
Spin Block readSDCard with 3 Parameters and 0 Extra Stack Longs. Method 8
pub readSDCard(address, bufAdr, size)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - address
Local Parameter DBASE:0008 - bufAdr
Local Parameter DBASE:000C - size
|===========================================================================|
104                         return ldr.readSDCard(address, bufAdr, size)
Addr : 14E0:             00  : Drop Anchor Push 
Addr : 14E1:             64  : Variable Operation Local Offset - 1 Read
Addr : 14E2:             68  : Variable Operation Local Offset - 2 Read
Addr : 14E3:             6C  : Variable Operation Local Offset - 3 Read
Addr : 14E4:       06 2B 06  : Call Obj.Sub 43 6
Addr : 14E7:             33  : Return value  
Addr : 14E8: Data : 32                       2
|===========================================================================|
Spin Block writeSDCard with 3 Parameters and 0 Extra Stack Longs. Method 9
pub writeSDCard(address, bufAdr, size)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - address
Local Parameter DBASE:0008 - bufAdr
Local Parameter DBASE:000C - size
|===========================================================================|
107                         return ldr.writeSDCard(address, bufAdr, size)
Addr : 14E9:             00  : Drop Anchor Push 
Addr : 14EA:             64  : Variable Operation Local Offset - 1 Read
Addr : 14EB:             68  : Variable Operation Local Offset - 2 Read
Addr : 14EC:             6C  : Variable Operation Local Offset - 3 Read
Addr : 14ED:       06 2B 07  : Call Obj.Sub 43 7
Addr : 14F0:             33  : Return value  
Addr : 14F1: Data : 32                       2
|===========================================================================|
Spin Block unmount with 0 Parameters and 0 Extra Stack Longs. Method 10
pub unmount

Local Parameter DBASE:0000 - Result
|===========================================================================|
110                         return ldr.stopSDCard
Addr : 14F2:             00  : Drop Anchor Push 
Addr : 14F3:       06 2B 05  : Call Obj.Sub 43 5
Addr : 14F6:             33  : Return value  
Addr : 14F7: Data : 32                       2
|===========================================================================|
Spin Block out with 1 Parameters and 0 Extra Stack Longs. Method 11
pub out(c)                        ' Output a single character

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - c
|===========================================================================|
113                         pputc(c)
Addr : 14F8:             01  : Drop Anchor   
Addr : 14F9:             64  : Variable Operation Local Offset - 1 Read
Addr : 14FA:          05 17  : Call Sub 23   
Addr : 14FC:             32  : Return        
|===========================================================================|
Spin Block str with 1 Parameters and 0 Extra Stack Longs. Method 12
pub str(stringptr)                ' Output a zero-terminated string

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - stringptr
|===========================================================================|
116                         repeat strsize(stringptr)
Addr : 14FD:             64  : Variable Operation Local Offset - 1 Read
Addr : 14FE:             16  : StrSize(String)
Addr : 14FF: TJZ Label0005
Addr : 14FF:          08 08  : tjz Address = 1509 8
Addr : 1501: Label0003
117                            pputc(byte[stringptr++])
Addr : 1501:             01  : Drop Anchor   
Addr : 1502:          66 AE  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long Push
Addr : 1504:             80  : Memory Op Byte POP Address READ 
Addr : 1505:          05 17  : Call Sub 23   
Addr : 1507: Label0004
Addr : 1507: DJNZ Label0003
Addr : 1507:          09 78  : djnz Address = 1501 -8
Addr : 1509: Label0005
Addr : 1509:             32  : Return        
|===========================================================================|
Spin Block dec with 1 Parameters and 1 Extra Stack Longs. Method 13
pub dec(value) | i                ' Output a decimal value

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - value
Local Variable  DBASE:0008 - i
|===========================================================================|
120                        if value < 0
Addr : 150A:             64  : Variable Operation Local Offset - 1 Read
Addr : 150B:             35  : Constant 1 $00000000
Addr : 150C:             F9  : Math Op <     
Addr : 150D: JZ Label0002
Addr : 150D:          0A 07  : jz Address = 1516 7
121                          -value
Addr : 150F:          66 46  : Variable Operation Local Offset - 1 Assign LongMathop -
122                          pputc("-")
Addr : 1511:             01  : Drop Anchor   
Addr : 1512:          38 2D  : Constant 1 Bytes - 2D - $0000002D 45
Addr : 1514:          05 17  : Call Sub 23   
Addr : 1516: Label0002
Addr : 1516: Label0003
123                        i := 1_000_000_000
Addr : 1516: 3B 3B 9A CA 00  : Constant 4 Bytes - 3B 9A CA 00 - $3B9ACA00 1000000000
Addr : 151B:             69  : Variable Operation Local Offset - 2 Write
124                        repeat 10
Addr : 151C:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 151E: TJZ Label0006
Addr : 151E:          08 27  : tjz Address = 1547 39
Addr : 1520: Label0004
125                          if value => i
Addr : 1520:             64  : Variable Operation Local Offset - 1 Read
Addr : 1521:             68  : Variable Operation Local Offset - 2 Read
Addr : 1522:             FE  : Math Op =>    
Addr : 1523: JZ Label0007
Addr : 1523:          0A 10  : jz Address = 1535 16
126                            pputc(value / i + "0")
Addr : 1525:             01  : Drop Anchor   
Addr : 1526:             64  : Variable Operation Local Offset - 1 Read
Addr : 1527:             68  : Variable Operation Local Offset - 2 Read
Addr : 1528:             F6  : Math Op /     
Addr : 1529:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 152B:             EC  : Math Op +     
Addr : 152C:          05 17  : Call Sub 23   
127                            value //= i
Addr : 152E:             68  : Variable Operation Local Offset - 2 Read
Addr : 152F:          66 57  : Variable Operation Local Offset - 1 Assign LongMathop //
128                            result~~
Addr : 1531:          62 1C  : Variable Operation Local Offset - 0 Assign VAR~~ Post-set
Addr : 1533: JMP Label0008
Addr : 1533:          04 0C  : Jmp 1541 12   
Addr : 1535: Label0007
129                          elseif result or i == 1
Addr : 1535:             60  : Variable Operation Local Offset - 0 Read
Addr : 1536:             68  : Variable Operation Local Offset - 2 Read
Addr : 1537:             36  : Constant 2 $00000001
Addr : 1538:             FC  : Math Op ==    
Addr : 1539:             F2  : Math Op OR    
Addr : 153A: JZ Label0009
Addr : 153A:          0A 05  : jz Address = 1541 5
130                            pputc("0")
Addr : 153C:             01  : Drop Anchor   
Addr : 153D:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 153F:          05 17  : Call Sub 23   
Addr : 1541: Label0009
Addr : 1541: Label0008
131                          i /= 10
Addr : 1541:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 1543:          6A 56  : Variable Operation Local Offset - 2 Assign LongMathop /
Addr : 1545: Label0005
Addr : 1545: DJNZ Label0004
Addr : 1545:          09 59  : djnz Address = 1520 -39
Addr : 1547: Label0006
Addr : 1547:             32  : Return        
|===========================================================================|
Spin Block hex with 2 Parameters and 0 Extra Stack Longs. Method 14
pub hex(value, digits)            ' Output a hexadecimal value

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - value
Local Parameter DBASE:0008 - digits
|===========================================================================|
134                        value <<= (8 - digits) << 2
Addr : 1548:          37 02  : Constant Mask Y=2 00000008 8
Addr : 154A:             68  : Variable Operation Local Offset - 2 Read
Addr : 154B:             ED  : Math Op -     
Addr : 154C:          37 00  : Constant Mask Y=0 00000002 2
Addr : 154E:             E3  : Math Op <<    
Addr : 154F:          66 43  : Variable Operation Local Offset - 1 Assign ByteMathop <<
135                        repeat digits
Addr : 1551:             68  : Variable Operation Local Offset - 2 Read
Addr : 1552: TJZ Label0004
Addr : 1552:          08 1B  : tjz Address = 156F 27
Addr : 1554: Label0002
136                          pputc(lookupz((value <-= 4) & $F : "0".."9", "A".."F"))
Addr : 1554:             01  : Drop Anchor   
Addr : 1555:             35  : Constant 1 $00000000
Addr : 1556: Constant Address of Label0005
Addr : 1556:       39 01 73  : Constant 2 Bytes - 01 73 - $00000173 371
Addr : 1559:          37 01  : Constant Mask Y=1 00000004 4
Addr : 155B:          66 C1  : Variable Operation Local Offset - 1 Assign BitMathop -< Push
Addr : 155D:          37 23  : Constant Mask Y=35 Decrement 0000000F 15
Addr : 155F:             E8  : Math Op &     
Addr : 1560:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 1562:          38 39  : Constant 1 Bytes - 39 - $00000039 57
Addr : 1564:             12  : Range LookUp  
Addr : 1565:          38 41  : Constant 1 Bytes - 41 - $00000041 65
Addr : 1567:          38 46  : Constant 1 Bytes - 46 - $00000046 70
Addr : 1569:             12  : Range LookUp  
Addr : 156A:             0F  : Lookdone      
Addr : 156B: Label0005
Addr : 156B:          05 17  : Call Sub 23   
Addr : 156D: Label0003
Addr : 156D: DJNZ Label0002
Addr : 156D:          09 65  : djnz Address = 1554 -27
Addr : 156F: Label0004
Addr : 156F:             32  : Return        
|===========================================================================|
Spin Block bin with 2 Parameters and 0 Extra Stack Longs. Method 15
pub bin(value, digits)            ' Output a binary value

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - value
Local Parameter DBASE:0008 - digits
|===========================================================================|
139                        value <<= 32 - digits
Addr : 1570:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1572:             68  : Variable Operation Local Offset - 2 Read
Addr : 1573:             ED  : Math Op -     
Addr : 1574:          66 43  : Variable Operation Local Offset - 1 Assign ByteMathop <<
140                        repeat digits
Addr : 1576:             68  : Variable Operation Local Offset - 2 Read
Addr : 1577: TJZ Label0004
Addr : 1577:          08 0D  : tjz Address = 1586 13
Addr : 1579: Label0002
141                          pputc((value <-= 1) & 1 + "0")
Addr : 1579:             01  : Drop Anchor   
Addr : 157A:             36  : Constant 2 $00000001
Addr : 157B:          66 C1  : Variable Operation Local Offset - 1 Assign BitMathop -< Push
Addr : 157D:             36  : Constant 2 $00000001
Addr : 157E:             E8  : Math Op &     
Addr : 157F:          38 30  : Constant 1 Bytes - 30 - $00000030 48
Addr : 1581:             EC  : Math Op +     
Addr : 1582:          05 17  : Call Sub 23   
Addr : 1584: Label0003
Addr : 1584: DJNZ Label0002
Addr : 1584:          09 73  : djnz Address = 1579 -13
Addr : 1586: Label0004
Addr : 1586:             32  : Return        
|===========================================================================|
Spin Block mount_explicit with 4 Parameters and 5 Extra Stack Longs. Method 16
pub mount_explicit(DO, Clk, DI, CS) | startBlk, sectorspercluster, reserved, rootentries, sectors

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - DO
Local Parameter DBASE:0008 - Clk
Local Parameter DBASE:000C - DI
Local Parameter DBASE:0010 - CS
Local Variable  DBASE:0014 - startBlk
Local Variable  DBASE:0018 - sectorspercluster
Local Variable  DBASE:001C - reserved
Local Variable  DBASE:0020 - rootentries
Local Variable  DBASE:0024 - sectors
|===========================================================================|
205                         if initSDCard(DO, Clk, DI, CS)
Addr : 1587:             00  : Drop Anchor Push 
Addr : 1588:             64  : Variable Operation Local Offset - 1 Read
Addr : 1589:             68  : Variable Operation Local Offset - 2 Read
Addr : 158A:             6C  : Variable Operation Local Offset - 3 Read
Addr : 158B:             70  : Variable Operation Local Offset - 4 Read
Addr : 158C:          05 05  : Call Sub 5    
Addr : 158E: JZ Label0003
Addr : 158E:          0A 03  : jz Address = 1593 3
206                            abort ($42) '-string("InitSDCard mount")
Addr : 1590:          38 42  : Constant 1 Bytes - 42 - $00000042 66
Addr : 1592:             31  : Abort value   
Addr : 1593: Label0003
Addr : 1593: Label0004
207                         lastread := -1
Addr : 1593:             34  : Constant 0 $FFFFFFFF
Addr : 1594:          C9 40  : Memory Op Long VBASE + WRITE Address = 0040
208                         dirty := 0
Addr : 1596:             35  : Constant 1 $00000000
Addr : 1597:          C9 44  : Memory Op Long VBASE + WRITE Address = 0044
209                         ldr.readSDCard(0, @buf, SECTORSIZE)
Addr : 1599:             01  : Drop Anchor   
Addr : 159A:             35  : Constant 1 $00000000
Addr : 159B:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 159D:          37 08  : Constant Mask Y=8 00000200 512
Addr : 159F:       06 2B 06  : Call Obj.Sub 43 6
210                         if (brlong(@buf+$36) == constant("F" + ("A" << 8) + ("T" << 16) + ("1" << 24)))
Addr : 15A2:             00  : Drop Anchor Push 
Addr : 15A3:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 15A5:          38 36  : Constant 1 Bytes - 36 - $00000036 54
Addr : 15A7:             EC  : Math Op +     
Addr : 15A8:          05 1E  : Call Sub 30   
Addr : 15AA: 3B 31 54 41 46  : Constant 4 Bytes - 31 54 41 46 - $31544146 827605318
Addr : 15AF:             FC  : Math Op ==    
Addr : 15B0: JZ Label0005
Addr : 15B0:          0A 04  : jz Address = 15B6 4
211                            startBlk := 0
Addr : 15B2:             35  : Constant 1 $00000000
Addr : 15B3:             75  : Variable Operation Local Offset - 5 Write
Addr : 15B4: JMP Label0006
Addr : 15B4:          04 13  : Jmp 15C9 19   
Addr : 15B6: Label0005
213                            startBlk := brlong(@buf+$1c6)
Addr : 15B6:             00  : Drop Anchor Push 
Addr : 15B7:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 15B9:       39 01 C6  : Constant 2 Bytes - 01 C6 - $000001C6 454
Addr : 15BC:             EC  : Math Op +     
Addr : 15BD:          05 1E  : Call Sub 30   
Addr : 15BF:             75  : Variable Operation Local Offset - 5 Write
214                            ldr.readSDCard(startBlk, @buf, SECTORSIZE)
Addr : 15C0:             01  : Drop Anchor   
Addr : 15C1:             74  : Variable Operation Local Offset - 5 Read
Addr : 15C2:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 15C4:          37 08  : Constant Mask Y=8 00000200 512
Addr : 15C6:       06 2B 06  : Call Obj.Sub 43 6
Addr : 15C9: Label0007
Addr : 15C9: Label0006
215                         if (brlong(@buf+$36) <> constant("F" + ("A" << 8) + ("T" << 16) + ("1" << 24)) or buf[$3a] <> "6")
Addr : 15C9:             00  : Drop Anchor Push 
Addr : 15CA:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 15CC:          38 36  : Constant 1 Bytes - 36 - $00000036 54
Addr : 15CE:             EC  : Math Op +     
Addr : 15CF:          05 1E  : Call Sub 30   
Addr : 15D1: 3B 31 54 41 46  : Constant 4 Bytes - 31 54 41 46 - $31544146 827605318
Addr : 15D6:             FB  : Math Op <>    
Addr : 15D7:          38 3A  : Constant 1 Bytes - 3A - $0000003A 58
Addr : 15D9:          98 48  : Memory Op Byte VBASE + POP Index READ Address = 0048
Addr : 15DB:          38 36  : Constant 1 Bytes - 36 - $00000036 54
Addr : 15DD:             FB  : Math Op <>    
Addr : 15DE:             F2  : Math Op OR    
Addr : 15DF: JZ Label0008
Addr : 15DF:          0A 04  : jz Address = 15E5 4
216                            abort(-20) ' not a fat16 volume
Addr : 15E1:          38 13  : Constant 1 Bytes - 13 - $00000013 19
Addr : 15E3:             E7  : Math Op !     
Addr : 15E4:             31  : Abort value   
Addr : 15E5: Label0008
Addr : 15E5: Label0009
217                         if (brword(@buf+$0b) <> SECTORSIZE)
Addr : 15E5:             00  : Drop Anchor Push 
Addr : 15E6:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 15E8:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 15EA:             EC  : Math Op +     
Addr : 15EB:          05 1D  : Call Sub 29   
Addr : 15ED:          37 08  : Constant Mask Y=8 00000200 512
Addr : 15EF:             FB  : Math Op <>    
Addr : 15F0: JZ Label000A
Addr : 15F0:          0A 04  : jz Address = 15F6 4
218                            abort(-21) ' bad bytes per sector
Addr : 15F2:          38 14  : Constant 1 Bytes - 14 - $00000014 20
Addr : 15F4:             E7  : Math Op !     
Addr : 15F5:             31  : Abort value   
Addr : 15F6: Label000A
Addr : 15F6: Label000B
219                         sectorspercluster := buf[$0d]
Addr : 15F6:          38 0D  : Constant 1 Bytes - 0D - $0000000D 13
Addr : 15F8:          98 48  : Memory Op Byte VBASE + POP Index READ Address = 0048
Addr : 15FA:             79  : Variable Operation Local Offset - 6 Write
220                         if (sectorspercluster & (sectorspercluster - 1))
Addr : 15FB:             78  : Variable Operation Local Offset - 6 Read
Addr : 15FC:             78  : Variable Operation Local Offset - 6 Read
Addr : 15FD:             36  : Constant 2 $00000001
Addr : 15FE:             ED  : Math Op -     
Addr : 15FF:             E8  : Math Op &     
Addr : 1600: JZ Label000C
Addr : 1600:          0A 04  : jz Address = 1606 4
221                            abort(-22) ' bad sectors per cluster
Addr : 1602:          38 15  : Constant 1 Bytes - 15 - $00000015 21
Addr : 1604:             E7  : Math Op !     
Addr : 1605:             31  : Abort value   
Addr : 1606: Label000C
Addr : 1606: Label000D
222                         clustershift := 0
Addr : 1606:             35  : Constant 1 $00000000
Addr : 1607:          C9 30  : Memory Op Long VBASE + WRITE Address = 0030
Addr : 1609: Label000E
223                         repeat while (sectorspercluster > 1)
Addr : 1609:             78  : Variable Operation Local Offset - 6 Read
Addr : 160A:             36  : Constant 2 $00000001
Addr : 160B:             FA  : Math Op >     
Addr : 160C: JZ Label0010
Addr : 160C:          0A 08  : jz Address = 1616 8
224                            clustershift++
Addr : 160E:       CA 30 2E  : Memory Op Long VBASE + ASSIGN Address = 0030 VAR++ post inc Long
225                            sectorspercluster >>= 1
Addr : 1611:             36  : Constant 2 $00000001
Addr : 1612:          7A 42  : Variable Operation Local Offset - 6 Assign ByteMathop >>
Addr : 1614: Label000F
Addr : 1614: JMP Label000E
Addr : 1614:          04 73  : Jmp 1609 -13  
Addr : 1616: Label0010
226                         sectorspercluster := 1 << clustershift
Addr : 1616:             36  : Constant 2 $00000001
Addr : 1617:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 1619:             E3  : Math Op <<    
Addr : 161A:             79  : Variable Operation Local Offset - 6 Write
227                         reserved := brword(@buf+$0e)
Addr : 161B:             00  : Drop Anchor Push 
Addr : 161C:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 161E:          38 0E  : Constant 1 Bytes - 0E - $0000000E 14
Addr : 1620:             EC  : Math Op +     
Addr : 1621:          05 1D  : Call Sub 29   
Addr : 1623:             7D  : Variable Operation Local Offset - 7 Write
228                         if (buf[$10] <> 2)
Addr : 1624:          37 03  : Constant Mask Y=3 00000010 16
Addr : 1626:          98 48  : Memory Op Byte VBASE + POP Index READ Address = 0048
Addr : 1628:          37 00  : Constant Mask Y=0 00000002 2
Addr : 162A:             FB  : Math Op <>    
Addr : 162B: JZ Label0011
Addr : 162B:          0A 04  : jz Address = 1631 4
229                            abort(-23) ' not two FATs
Addr : 162D:          38 16  : Constant 1 Bytes - 16 - $00000016 22
Addr : 162F:             E7  : Math Op !     
Addr : 1630:             31  : Abort value   
Addr : 1631: Label0011
Addr : 1631: Label0012
230                         rootentries := brword(@buf+$11)
Addr : 1631:             00  : Drop Anchor Push 
Addr : 1632:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 1634:          38 11  : Constant 1 Bytes - 11 - $00000011 17
Addr : 1636:             EC  : Math Op +     
Addr : 1637:          05 1D  : Call Sub 29   
Addr : 1639:          CD 20  : Memory Op Long DBASE + WRITE Address = 0020
231                         sectors := brword(@buf+$13)
Addr : 163B:             00  : Drop Anchor Push 
Addr : 163C:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 163E:          38 13  : Constant 1 Bytes - 13 - $00000013 19
Addr : 1640:             EC  : Math Op +     
Addr : 1641:          05 1D  : Call Sub 29   
Addr : 1643:          CD 24  : Memory Op Long DBASE + WRITE Address = 0024
232                         if (sectors == 0)
Addr : 1645:          CC 24  : Memory Op Long DBASE + READ Address = 0024
Addr : 1647:             35  : Constant 1 $00000000
Addr : 1648:             FC  : Math Op ==    
Addr : 1649: JZ Label0013
Addr : 1649:          0A 0A  : jz Address = 1655 10
233                            sectors := brlong(@buf+$20)
Addr : 164B:             00  : Drop Anchor Push 
Addr : 164C:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 164E:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1650:             EC  : Math Op +     
Addr : 1651:          05 1E  : Call Sub 30   
Addr : 1653:          CD 24  : Memory Op Long DBASE + WRITE Address = 0024
Addr : 1655: Label0013
Addr : 1655: Label0014
234                         sectorsperfat := brword(@buf+$16)
Addr : 1655:             00  : Drop Anchor Push 
Addr : 1656:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 1658:          38 16  : Constant 1 Bytes - 16 - $00000016 22
Addr : 165A:             EC  : Math Op +     
Addr : 165B:          05 1D  : Call Sub 29   
Addr : 165D:          C9 3C  : Memory Op Long VBASE + WRITE Address = 003C
235                         if (brword(@buf+$1fe) <> $aa55)
Addr : 165F:             00  : Drop Anchor Push 
Addr : 1660:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 1662:       39 01 FE  : Constant 2 Bytes - 01 FE - $000001FE 510
Addr : 1665:             EC  : Math Op +     
Addr : 1666:          05 1D  : Call Sub 29   
Addr : 1668:       39 AA 55  : Constant 2 Bytes - AA 55 - $0000AA55 43605
Addr : 166B:             FB  : Math Op <>    
Addr : 166C: JZ Label0015
Addr : 166C:          0A 04  : jz Address = 1672 4
236                            abort(-24) ' bad FAT signature
Addr : 166E:          38 17  : Constant 1 Bytes - 17 - $00000017 23
Addr : 1670:             E7  : Math Op !     
Addr : 1671:             31  : Abort value   
Addr : 1672: Label0015
Addr : 1672: Label0016
237                         fat1 := startBlk + reserved
Addr : 1672:             74  : Variable Operation Local Offset - 5 Read
Addr : 1673:             7C  : Variable Operation Local Offset - 7 Read
Addr : 1674:             EC  : Math Op +     
Addr : 1675:          C9 34  : Memory Op Long VBASE + WRITE Address = 0034
238                         rootdir := (fat1 + 2 * sectorsperfat) << SECTORSHIFT
Addr : 1677:          C8 34  : Memory Op Long VBASE + READ Address = 0034
Addr : 1679:          37 00  : Constant Mask Y=0 00000002 2
Addr : 167B:          C8 3C  : Memory Op Long VBASE + READ Address = 003C
Addr : 167D:             F4  : Math Op *     
Addr : 167E:             EC  : Math Op +     
Addr : 167F:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 1681:             E3  : Math Op <<    
Addr : 1682:          C9 24  : Memory Op Long VBASE + WRITE Address = 0024
239                         rootdirend := rootdir + (rootentries << DIRSHIFT)
Addr : 1684:          C8 24  : Memory Op Long VBASE + READ Address = 0024
Addr : 1686:          CC 20  : Memory Op Long DBASE + READ Address = 0020
Addr : 1688:          38 05  : Constant 1 Bytes - 05 - $00000005 5
Addr : 168A:             E3  : Math Op <<    
Addr : 168B:             EC  : Math Op +     
Addr : 168C:          C9 28  : Memory Op Long VBASE + WRITE Address = 0028
240                         dataregion := 1 + ((rootdirend - 1) >> SECTORSHIFT) - 2 * sectorspercluster
Addr : 168E:             36  : Constant 2 $00000001
Addr : 168F:          C8 28  : Memory Op Long VBASE + READ Address = 0028
Addr : 1691:             36  : Constant 2 $00000001
Addr : 1692:             ED  : Math Op -     
Addr : 1693:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 1695:             E2  : Math Op >>    
Addr : 1696:             EC  : Math Op +     
Addr : 1697:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1699:             78  : Variable Operation Local Offset - 6 Read
Addr : 169A:             F4  : Math Op *     
Addr : 169B:             ED  : Math Op -     
Addr : 169C:          C9 2C  : Memory Op Long VBASE + WRITE Address = 002C
241                         totclusters := ((sectors - dataregion + startBlk) >> clustershift)
Addr : 169E:          CC 24  : Memory Op Long DBASE + READ Address = 0024
Addr : 16A0:          C8 2C  : Memory Op Long VBASE + READ Address = 002C
Addr : 16A2:             ED  : Math Op -     
Addr : 16A3:             74  : Variable Operation Local Offset - 5 Read
Addr : 16A4:             EC  : Math Op +     
Addr : 16A5:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 16A7:             E2  : Math Op >>    
Addr : 16A8:          C9 38  : Memory Op Long VBASE + WRITE Address = 0038
242                         if (totclusters > $fff0)
Addr : 16AA:          C8 38  : Memory Op Long VBASE + READ Address = 0038
Addr : 16AC:       39 FF F0  : Constant 2 Bytes - FF F0 - $0000FFF0 65520
Addr : 16AF:             FA  : Math Op >     
Addr : 16B0: JZ Label0017
Addr : 16B0:          0A 04  : jz Address = 16B6 4
243                            abort(-25) ' too many clusters
Addr : 16B2:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 16B4:             E7  : Math Op !     
Addr : 16B5:             31  : Abort value   
Addr : 16B6: Label0017
Addr : 16B6: Label0018
244                         return 0
Addr : 16B6:             35  : Constant 1 $00000000
Addr : 16B7:             33  : Return value  
Addr : 16B8: Data : 32                       2
|===========================================================================|
Spin Block pflush with 0 Parameters and 0 Extra Stack Longs. Method 17
pub pflush

Local Parameter DBASE:0000 - Result
|===========================================================================|
370                         return pflushbuf(bufat, 1)
Addr : 16B9:             00  : Drop Anchor Push 
Addr : 16BA:             50  : Variable Operation Global Offset - 4 Read
Addr : 16BB:             36  : Constant 2 $00000001
Addr : 16BC:          05 28  : Call Sub 40   
Addr : 16BE:             33  : Return value  
Addr : 16BF: Data : 32                       2
|===========================================================================|
Spin Block pclose with 0 Parameters and 1 Extra Stack Longs. Method 18
pub pclose | r

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - r
|===========================================================================|
400                         r := 0
Addr : 16C0:             35  : Constant 1 $00000000
Addr : 16C1:             65  : Variable Operation Local Offset - 1 Write
401                         if (direntry)
Addr : 16C2:             5C  : Variable Operation Global Offset - 7 Read
Addr : 16C3: JZ Label0003
Addr : 16C3:          0A 04  : jz Address = 16C9 4
402                            r := pflush
Addr : 16C5:             00  : Drop Anchor Push 
Addr : 16C6:          05 11  : Call Sub 17   
Addr : 16C8:             65  : Variable Operation Local Offset - 1 Write
Addr : 16C9: Label0003
Addr : 16C9: Label0004
403                         bufat := 0
Addr : 16C9:             35  : Constant 1 $00000000
Addr : 16CA:             51  : Variable Operation Global Offset - 4 Write
404                         bufend := 0
Addr : 16CB:             35  : Constant 1 $00000000
Addr : 16CC:             55  : Variable Operation Global Offset - 5 Write
405                         filesize := 0
Addr : 16CD:             35  : Constant 1 $00000000
Addr : 16CE:             45  : Variable Operation Global Offset - 1 Write
406                         floc := 0
Addr : 16CF:             35  : Constant 1 $00000000
Addr : 16D0:             49  : Variable Operation Global Offset - 2 Write
407                         frem := 0
Addr : 16D1:             35  : Constant 1 $00000000
Addr : 16D2:             4D  : Variable Operation Global Offset - 3 Write
408                         writelink := 0
Addr : 16D3:             35  : Constant 1 $00000000
Addr : 16D4:             59  : Variable Operation Global Offset - 6 Write
409                         direntry := 0
Addr : 16D5:             35  : Constant 1 $00000000
Addr : 16D6:             5D  : Variable Operation Global Offset - 7 Write
410                         fclust := 0
Addr : 16D7:             35  : Constant 1 $00000000
Addr : 16D8:             41  : Variable Operation Global Offset - 0 Write
411                         return r
Addr : 16D9:             64  : Variable Operation Local Offset - 1 Read
Addr : 16DA:             33  : Return value  
Addr : 16DB: Data : 32                       2
|===========================================================================|
Spin Block popen with 2 Parameters and 4 Extra Stack Longs. Method 19
pub popen(s, mode) | i, sentinel, dirptr, freeentry

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - s
Local Parameter DBASE:0008 - mode
Local Variable  DBASE:000C - i
Local Variable  DBASE:0010 - sentinel
Local Variable  DBASE:0014 - dirptr
Local Variable  DBASE:0018 - freeentry
|===========================================================================|
432                         pclose
Addr : 16DC:             01  : Drop Anchor   
Addr : 16DD:          05 12  : Call Sub 18   
433                         i := 0
Addr : 16DF:             35  : Constant 1 $00000000
Addr : 16E0:             6D  : Variable Operation Local Offset - 3 Write
Addr : 16E1: Label0003
434                         repeat while (i<8 and byte[s] and byte[s] <> ".")
Addr : 16E1:             6C  : Variable Operation Local Offset - 3 Read
Addr : 16E2:          37 02  : Constant Mask Y=2 00000008 8
Addr : 16E4:             F9  : Math Op <     
Addr : 16E5:             64  : Variable Operation Local Offset - 1 Read
Addr : 16E6:             80  : Memory Op Byte POP Address READ 
Addr : 16E7:             F0  : Math Op AND   
Addr : 16E8:             64  : Variable Operation Local Offset - 1 Read
Addr : 16E9:             80  : Memory Op Byte POP Address READ 
Addr : 16EA:          38 2E  : Constant 1 Bytes - 2E - $0000002E 46
Addr : 16EC:             FB  : Math Op <>    
Addr : 16ED:             F0  : Math Op AND   
Addr : 16EE: JZ Label0005
Addr : 16EE:          0A 0D  : jz Address = 16FD 13
435                            padname[i++] := uc(byte[s++])
Addr : 16F0:             00  : Drop Anchor Push 
Addr : 16F1:          66 AE  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long Push
Addr : 16F3:             80  : Memory Op Byte POP Address READ 
Addr : 16F4:          05 27  : Call Sub 39   
Addr : 16F6:          6E AE  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long Push
Addr : 16F8:       99 84 48  : Memory Op Byte VBASE + POP Index WRITE Address = 0448
Addr : 16FB: Label0004
Addr : 16FB: JMP Label0003
Addr : 16FB:          04 64  : Jmp 16E1 -28  
Addr : 16FD: Label0005
Addr : 16FD: Label0006
436                         repeat while (i<8)
Addr : 16FD:             6C  : Variable Operation Local Offset - 3 Read
Addr : 16FE:          37 02  : Constant Mask Y=2 00000008 8
Addr : 1700:             F9  : Math Op <     
Addr : 1701: JZ Label0008
Addr : 1701:          0A 09  : jz Address = 170C 9
437                            padname[i++] := " "
Addr : 1703:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1705:          6E AE  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long Push
Addr : 1707:       99 84 48  : Memory Op Byte VBASE + POP Index WRITE Address = 0448
Addr : 170A: Label0007
Addr : 170A: JMP Label0006
Addr : 170A:          04 71  : Jmp 16FD -15  
Addr : 170C: Label0008
Addr : 170C: Label0009
438                         repeat while (byte[s] and byte[s] <> ".")
Addr : 170C:             64  : Variable Operation Local Offset - 1 Read
Addr : 170D:             80  : Memory Op Byte POP Address READ 
Addr : 170E:             64  : Variable Operation Local Offset - 1 Read
Addr : 170F:             80  : Memory Op Byte POP Address READ 
Addr : 1710:          38 2E  : Constant 1 Bytes - 2E - $0000002E 46
Addr : 1712:             FB  : Math Op <>    
Addr : 1713:             F0  : Math Op AND   
Addr : 1714: JZ Label000B
Addr : 1714:          0A 04  : jz Address = 171A 4
439                            s++
Addr : 1716:          66 2E  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long
Addr : 1718: Label000A
Addr : 1718: JMP Label0009
Addr : 1718:          04 72  : Jmp 170C -14  
Addr : 171A: Label000B
440                         if (byte[s] == ".")
Addr : 171A:             64  : Variable Operation Local Offset - 1 Read
Addr : 171B:             80  : Memory Op Byte POP Address READ 
Addr : 171C:          38 2E  : Constant 1 Bytes - 2E - $0000002E 46
Addr : 171E:             FC  : Math Op ==    
Addr : 171F: JZ Label000C
Addr : 171F:          0A 02  : jz Address = 1723 2
441                            s++
Addr : 1721:          66 2E  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long
Addr : 1723: Label000C
Addr : 1723: Label000D
Addr : 1723: Label000E
442                         repeat while (i<11 and byte[s])
Addr : 1723:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1724:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 1726:             F9  : Math Op <     
Addr : 1727:             64  : Variable Operation Local Offset - 1 Read
Addr : 1728:             80  : Memory Op Byte POP Address READ 
Addr : 1729:             F0  : Math Op AND   
Addr : 172A: JZ Label0010
Addr : 172A:          0A 0D  : jz Address = 1739 13
443                            padname[i++] := uc(byte[s++])
Addr : 172C:             00  : Drop Anchor Push 
Addr : 172D:          66 AE  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long Push
Addr : 172F:             80  : Memory Op Byte POP Address READ 
Addr : 1730:          05 27  : Call Sub 39   
Addr : 1732:          6E AE  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long Push
Addr : 1734:       99 84 48  : Memory Op Byte VBASE + POP Index WRITE Address = 0448
Addr : 1737: Label000F
Addr : 1737: JMP Label000E
Addr : 1737:          04 6A  : Jmp 1723 -22  
Addr : 1739: Label0010
Addr : 1739: Label0011
444                         repeat while (i < 11)
Addr : 1739:             6C  : Variable Operation Local Offset - 3 Read
Addr : 173A:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 173C:             F9  : Math Op <     
Addr : 173D: JZ Label0013
Addr : 173D:          0A 09  : jz Address = 1748 9
445                            padname[i++] := " "
Addr : 173F:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1741:          6E AE  : Variable Operation Local Offset - 3 Assign VAR++ post inc Long Push
Addr : 1743:       99 84 48  : Memory Op Byte VBASE + POP Index WRITE Address = 0448
Addr : 1746: Label0012
Addr : 1746: JMP Label0011
Addr : 1746:          04 71  : Jmp 1739 -15  
Addr : 1748: Label0013
446                         sentinel := 0
Addr : 1748:             35  : Constant 1 $00000000
Addr : 1749:             71  : Variable Operation Local Offset - 4 Write
447                         freeentry := 0
Addr : 174A:             35  : Constant 1 $00000000
Addr : 174B:             79  : Variable Operation Local Offset - 6 Write
448                         repeat dirptr from rootdir to rootdirend - DIRSIZE step DIRSIZE
Addr : 174C:          C8 24  : Memory Op Long VBASE + READ Address = 0024
Addr : 174E:             75  : Variable Operation Local Offset - 5 Write
Addr : 174F: Label0014
449                            s := readbytec(dirptr)
Addr : 174F:             00  : Drop Anchor Push 
Addr : 1750:             74  : Variable Operation Local Offset - 5 Read
Addr : 1751:          05 21  : Call Sub 33   
Addr : 1753:             65  : Variable Operation Local Offset - 1 Write
450                            if (freeentry == 0 and (byte[s] == 0 or byte[s] == $e5))
Addr : 1754:             78  : Variable Operation Local Offset - 6 Read
Addr : 1755:             35  : Constant 1 $00000000
Addr : 1756:             FC  : Math Op ==    
Addr : 1757:             64  : Variable Operation Local Offset - 1 Read
Addr : 1758:             80  : Memory Op Byte POP Address READ 
Addr : 1759:             35  : Constant 1 $00000000
Addr : 175A:             FC  : Math Op ==    
Addr : 175B:             64  : Variable Operation Local Offset - 1 Read
Addr : 175C:             80  : Memory Op Byte POP Address READ 
Addr : 175D:          38 E5  : Constant 1 Bytes - E5 - $000000E5 229
Addr : 175F:             FC  : Math Op ==    
Addr : 1760:             F2  : Math Op OR    
Addr : 1761:             F0  : Math Op AND   
Addr : 1762: JZ Label0017
Addr : 1762:          0A 02  : jz Address = 1766 2
451                               freeentry := dirptr
Addr : 1764:             74  : Variable Operation Local Offset - 5 Read
Addr : 1765:             79  : Variable Operation Local Offset - 6 Write
Addr : 1766: Label0017
Addr : 1766: Label0018
452                            if (byte[s] == 0)
Addr : 1766:             64  : Variable Operation Local Offset - 1 Read
Addr : 1767:             80  : Memory Op Byte POP Address READ 
Addr : 1768:             35  : Constant 1 $00000000
Addr : 1769:             FC  : Math Op ==    
Addr : 176A: JZ Label0019
Addr : 176A:          0A 05  : jz Address = 1771 5
453                               sentinel := dirptr
Addr : 176C:             74  : Variable Operation Local Offset - 5 Read
Addr : 176D:             71  : Variable Operation Local Offset - 4 Write
454                               quit
Addr : 176E: JMP Label0016
Addr : 176E:       04 81 2A  : Jmp 189B 298  
Addr : 1771: Label0019
Addr : 1771: Label001A
455                            repeat i from 0 to 10
Addr : 1771:             35  : Constant 1 $00000000
Addr : 1772:             6D  : Variable Operation Local Offset - 3 Write
Addr : 1773: Label001B
456                               if (padname[i] <> byte[s][i])
Addr : 1773:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1774:       98 84 48  : Memory Op Byte VBASE + POP Index READ Address = 0448
Addr : 1777:             64  : Variable Operation Local Offset - 1 Read
Addr : 1778:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1779:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 177A:             FB  : Math Op <>    
Addr : 177B: JZ Label001E
Addr : 177B:          0A 02  : jz Address = 177F 2
457                                  quit
Addr : 177D: JMP Label001D
Addr : 177D:          04 06  : Jmp 1785 6    
Addr : 177F: Label001E
Addr : 177F: Label001F
Addr : 177F: Label001C
455                            repeat i from 0 to 10
Addr : 177F:             35  : Constant 1 $00000000
Addr : 1780:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 1782: Repeat i Step Label001B
Addr : 1782:       6E 02 6E  : Variable Operation Local Offset - 3 Assign Repeat-Var loop Address= 1773 -18
Addr : 1785: Label001D
458                            if (i == 11 and 0 == (byte[s][$0b] & $18)) ' this always returns
Addr : 1785:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1786:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 1788:             FC  : Math Op ==    
Addr : 1789:             35  : Constant 1 $00000000
Addr : 178A:             64  : Variable Operation Local Offset - 1 Read
Addr : 178B:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 178D:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 178E:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 1790:             E8  : Math Op &     
Addr : 1791:             FC  : Math Op ==    
Addr : 1792:             F0  : Math Op AND   
Addr : 1793: JZ Label0020
Addr : 1793:       0A 80 F8  : jz Address = 188E 248
459                               fclust := brword(s+$1a)
Addr : 1796:             00  : Drop Anchor Push 
Addr : 1797:             64  : Variable Operation Local Offset - 1 Read
Addr : 1798:          38 1A  : Constant 1 Bytes - 1A - $0000001A 26
Addr : 179A:             EC  : Math Op +     
Addr : 179B:          05 1D  : Call Sub 29   
Addr : 179D:             41  : Variable Operation Global Offset - 0 Write
460                               filesize := brlong(s+$1c)
Addr : 179E:             00  : Drop Anchor Push 
Addr : 179F:             64  : Variable Operation Local Offset - 1 Read
Addr : 17A0:          38 1C  : Constant 1 Bytes - 1C - $0000001C 28
Addr : 17A2:             EC  : Math Op +     
Addr : 17A3:          05 1E  : Call Sub 30   
Addr : 17A5:             45  : Variable Operation Global Offset - 1 Write
461                               if (mode == "r")
Addr : 17A6:             68  : Variable Operation Local Offset - 2 Read
Addr : 17A7:          38 72  : Constant 1 Bytes - 72 - $00000072 114
Addr : 17A9:             FC  : Math Op ==    
Addr : 17AA: JZ Label0022
Addr : 17AA:          0A 0F  : jz Address = 17BB 15
462                                  frem := SECTORSIZE << clustershift
Addr : 17AC:          37 08  : Constant Mask Y=8 00000200 512
Addr : 17AE:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 17B0:             E3  : Math Op <<    
Addr : 17B1:             4D  : Variable Operation Global Offset - 3 Write
463                                  if (frem > filesize)
Addr : 17B2:             4C  : Variable Operation Global Offset - 3 Read
Addr : 17B3:             44  : Variable Operation Global Offset - 1 Read
Addr : 17B4:             FA  : Math Op >     
Addr : 17B5: JZ Label0024
Addr : 17B5:          0A 02  : jz Address = 17B9 2
464                                     frem := filesize
Addr : 17B7:             44  : Variable Operation Global Offset - 1 Read
Addr : 17B8:             4D  : Variable Operation Global Offset - 3 Write
Addr : 17B9: Label0024
Addr : 17B9: Label0025
465                                  return 0
Addr : 17B9:             35  : Constant 1 $00000000
Addr : 17BA:             33  : Return value  
Addr : 17BB: Label0022
Addr : 17BB: Label0023
466                               if (byte[s][11] & $d9)
Addr : 17BB:             64  : Variable Operation Local Offset - 1 Read
Addr : 17BC:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 17BE:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 17BF:          38 D9  : Constant 1 Bytes - D9 - $000000D9 217
Addr : 17C1:             E8  : Math Op &     
Addr : 17C2: JZ Label0026
Addr : 17C2:          0A 04  : jz Address = 17C8 4
467                                  abort(-6) ' no permission to write
Addr : 17C4:          38 05  : Constant 1 Bytes - 05 - $00000005 5
Addr : 17C6:             E7  : Math Op !     
Addr : 17C7:             31  : Abort value   
Addr : 17C8: Label0026
Addr : 17C8: Label0027
468                               if (mode == "d")
Addr : 17C8:             68  : Variable Operation Local Offset - 2 Read
Addr : 17C9:          38 64  : Constant 1 Bytes - 64 - $00000064 100
Addr : 17CB:             FC  : Math Op ==    
Addr : 17CC: JZ Label0028
Addr : 17CC:          0A 0F  : jz Address = 17DD 15
469                                  brwword(s, $e5)
Addr : 17CE:             01  : Drop Anchor   
Addr : 17CF:             64  : Variable Operation Local Offset - 1 Read
Addr : 17D0:          38 E5  : Constant 1 Bytes - E5 - $000000E5 229
Addr : 17D2:          05 1F  : Call Sub 31   
470                                  freeclusters(fclust)
Addr : 17D4:             01  : Drop Anchor   
Addr : 17D5:             40  : Variable Operation Global Offset - 0 Read
Addr : 17D6:          05 25  : Call Sub 37   
471                                  flushifdirty
Addr : 17D8:             01  : Drop Anchor   
Addr : 17D9:          05 1B  : Call Sub 27   
472                                  return 0
Addr : 17DB:             35  : Constant 1 $00000000
Addr : 17DC:             33  : Return value  
Addr : 17DD: Label0028
Addr : 17DD: Label0029
473                               if (mode == "w")
Addr : 17DD:             68  : Variable Operation Local Offset - 2 Read
Addr : 17DE:          38 77  : Constant 1 Bytes - 77 - $00000077 119
Addr : 17E0:             FC  : Math Op ==    
Addr : 17E1: JZ Label002A
Addr : 17E1:          0A 29  : jz Address = 180C 41
474                                  brwword(s+26, -1)
Addr : 17E3:             01  : Drop Anchor   
Addr : 17E4:             64  : Variable Operation Local Offset - 1 Read
Addr : 17E5:          38 1A  : Constant 1 Bytes - 1A - $0000001A 26
Addr : 17E7:             EC  : Math Op +     
Addr : 17E8:             34  : Constant 0 $FFFFFFFF
Addr : 17E9:          05 1F  : Call Sub 31   
475                                  brwlong(s+28, 0)
Addr : 17EB:             01  : Drop Anchor   
Addr : 17EC:             64  : Variable Operation Local Offset - 1 Read
Addr : 17ED:          38 1C  : Constant 1 Bytes - 1C - $0000001C 28
Addr : 17EF:             EC  : Math Op +     
Addr : 17F0:             35  : Constant 1 $00000000
Addr : 17F1:          05 20  : Call Sub 32   
476                                  writelink := dirptr + 26
Addr : 17F3:             74  : Variable Operation Local Offset - 5 Read
Addr : 17F4:          38 1A  : Constant 1 Bytes - 1A - $0000001A 26
Addr : 17F6:             EC  : Math Op +     
Addr : 17F7:             59  : Variable Operation Global Offset - 6 Write
477                                  direntry := dirptr
Addr : 17F8:             74  : Variable Operation Local Offset - 5 Read
Addr : 17F9:             5D  : Variable Operation Global Offset - 7 Write
478                                  freeclusters(fclust)
Addr : 17FA:             01  : Drop Anchor   
Addr : 17FB:             40  : Variable Operation Global Offset - 0 Read
Addr : 17FC:          05 25  : Call Sub 37   
479                                  bufend := SECTORSIZE
Addr : 17FE:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1800:             55  : Variable Operation Global Offset - 5 Write
480                                  fclust := 0
Addr : 1801:             35  : Constant 1 $00000000
Addr : 1802:             41  : Variable Operation Global Offset - 0 Write
481                                  filesize := 0
Addr : 1803:             35  : Constant 1 $00000000
Addr : 1804:             45  : Variable Operation Global Offset - 1 Write
482                                  frem := 0
Addr : 1805:             35  : Constant 1 $00000000
Addr : 1806:             4D  : Variable Operation Global Offset - 3 Write
483                                  return 0
Addr : 1807:             35  : Constant 1 $00000000
Addr : 1808:             33  : Return value  
Addr : 1809: JMP Label002B
Addr : 1809:       04 80 82  : Jmp 188E 130  
Addr : 180C: Label002A
484                               elseif (mode == "a")
Addr : 180C:             68  : Variable Operation Local Offset - 2 Read
Addr : 180D:          38 61  : Constant 1 Bytes - 61 - $00000061 97
Addr : 180F:             FC  : Math Op ==    
Addr : 1810: JZ Label002C
Addr : 1810:       0A 80 78  : jz Address = 188B 120
486                                  frem := filesize
Addr : 1813:             44  : Variable Operation Global Offset - 1 Read
Addr : 1814:             4D  : Variable Operation Global Offset - 3 Write
487                                  freeentry := SECTORSIZE << clustershift
Addr : 1815:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1817:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 1819:             E3  : Math Op <<    
Addr : 181A:             79  : Variable Operation Local Offset - 6 Write
488                                  if (fclust => $fff0)
Addr : 181B:             40  : Variable Operation Global Offset - 0 Read
Addr : 181C:       39 FF F0  : Constant 2 Bytes - FF F0 - $0000FFF0 65520
Addr : 181F:             FE  : Math Op =>    
Addr : 1820: JZ Label002D
Addr : 1820:          0A 02  : jz Address = 1824 2
489                                     fclust := 0
Addr : 1822:             35  : Constant 1 $00000000
Addr : 1823:             41  : Variable Operation Global Offset - 0 Write
Addr : 1824: Label002D
Addr : 1824: Label002E
Addr : 1824: Label002F
490                                  repeat while (frem > freeentry)
Addr : 1824:             4C  : Variable Operation Global Offset - 3 Read
Addr : 1825:             78  : Variable Operation Local Offset - 6 Read
Addr : 1826:             FA  : Math Op >     
Addr : 1827: JZ Label0031
Addr : 1827:          0A 13  : jz Address = 183C 19
491                                     if (fclust < 2)
Addr : 1829:             40  : Variable Operation Global Offset - 0 Read
Addr : 182A:          37 00  : Constant Mask Y=0 00000002 2
Addr : 182C:             F9  : Math Op <     
Addr : 182D: JZ Label0032
Addr : 182D:          0A 04  : jz Address = 1833 4
492                                        abort(-7) ' eof repeat while following chain
Addr : 182F:          38 06  : Constant 1 Bytes - 06 - $00000006 6
Addr : 1831:             E7  : Math Op !     
Addr : 1832:             31  : Abort value   
Addr : 1833: Label0032
Addr : 1833: Label0033
493                                     fclust := nextcluster
Addr : 1833:             00  : Drop Anchor Push 
Addr : 1834:          05 24  : Call Sub 36   
Addr : 1836:             41  : Variable Operation Global Offset - 0 Write
494                                     frem -= freeentry
Addr : 1837:             78  : Variable Operation Local Offset - 6 Read
Addr : 1838:          4E 4D  : Variable Operation Global Offset - 3 Assign WordMathop -
Addr : 183A: Label0030
Addr : 183A: JMP Label002F
Addr : 183A:          04 68  : Jmp 1824 -24  
Addr : 183C: Label0031
495                                  floc := filesize & constant(!(SECTORSIZE - 1))
Addr : 183C:             44  : Variable Operation Global Offset - 1 Read
Addr : 183D:          37 68  : Constant Mask Y=104 Decrement Invert FFFFFE00 4294966784
Addr : 183F:             E8  : Math Op &     
Addr : 1840:             49  : Variable Operation Global Offset - 2 Write
496                                  bufend := SECTORSIZE
Addr : 1841:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1843:             55  : Variable Operation Global Offset - 5 Write
497                                  bufat := frem & constant(SECTORSIZE - 1)
Addr : 1844:             4C  : Variable Operation Global Offset - 3 Read
Addr : 1845:          37 28  : Constant Mask Y=40 Decrement 000001FF 511
Addr : 1847:             E8  : Math Op &     
Addr : 1848:             51  : Variable Operation Global Offset - 4 Write
498                                  writelink := dirptr + 26
Addr : 1849:             74  : Variable Operation Local Offset - 5 Read
Addr : 184A:          38 1A  : Constant 1 Bytes - 1A - $0000001A 26
Addr : 184C:             EC  : Math Op +     
Addr : 184D:             59  : Variable Operation Global Offset - 6 Write
499                                  direntry := dirptr
Addr : 184E:             74  : Variable Operation Local Offset - 5 Read
Addr : 184F:             5D  : Variable Operation Global Offset - 7 Write
500                                  if (bufat)
Addr : 1850:             50  : Variable Operation Global Offset - 4 Read
Addr : 1851: JZ Label0034
Addr : 1851:          0A 15  : jz Address = 1868 21
501                                     ldr.readSDCard(datablock, @buf, SECTORSIZE)
Addr : 1853:             01  : Drop Anchor   
Addr : 1854:             00  : Drop Anchor Push 
Addr : 1855:          05 26  : Call Sub 38   
Addr : 1857:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 1859:          37 08  : Constant Mask Y=8 00000200 512
Addr : 185B:       06 2B 06  : Call Obj.Sub 43 6
502                                     frem := freeentry - (floc & (freeentry - 1))
Addr : 185E:             78  : Variable Operation Local Offset - 6 Read
Addr : 185F:             48  : Variable Operation Global Offset - 2 Read
Addr : 1860:             78  : Variable Operation Local Offset - 6 Read
Addr : 1861:             36  : Constant 2 $00000001
Addr : 1862:             ED  : Math Op -     
Addr : 1863:             E8  : Math Op &     
Addr : 1864:             ED  : Math Op -     
Addr : 1865:             4D  : Variable Operation Global Offset - 3 Write
Addr : 1866: JMP Label0035
Addr : 1866:          04 16  : Jmp 187E 22   
Addr : 1868: Label0034
504                                     if (fclust < 2 or frem == freeentry)
Addr : 1868:             40  : Variable Operation Global Offset - 0 Read
Addr : 1869:          37 00  : Constant Mask Y=0 00000002 2
Addr : 186B:             F9  : Math Op <     
Addr : 186C:             4C  : Variable Operation Global Offset - 3 Read
Addr : 186D:             78  : Variable Operation Local Offset - 6 Read
Addr : 186E:             FC  : Math Op ==    
Addr : 186F:             F2  : Math Op OR    
Addr : 1870: JZ Label0037
Addr : 1870:          0A 04  : jz Address = 1876 4
505                                        frem := 0
Addr : 1872:             35  : Constant 1 $00000000
Addr : 1873:             4D  : Variable Operation Global Offset - 3 Write
Addr : 1874: JMP Label0038
Addr : 1874:          04 08  : Jmp 187E 8    
Addr : 1876: Label0037
507                                        frem := freeentry - (floc & (freeentry - 1))
Addr : 1876:             78  : Variable Operation Local Offset - 6 Read
Addr : 1877:             48  : Variable Operation Global Offset - 2 Read
Addr : 1878:             78  : Variable Operation Local Offset - 6 Read
Addr : 1879:             36  : Constant 2 $00000001
Addr : 187A:             ED  : Math Op -     
Addr : 187B:             E8  : Math Op &     
Addr : 187C:             ED  : Math Op -     
Addr : 187D:             4D  : Variable Operation Global Offset - 3 Write
Addr : 187E: Label0039
Addr : 187E: Label0038
Addr : 187E: Label0036
Addr : 187E: Label0035
508                                  if (fclust => 2)
Addr : 187E:             40  : Variable Operation Global Offset - 0 Read
Addr : 187F:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1881:             FE  : Math Op =>    
Addr : 1882: JZ Label003A
Addr : 1882:          0A 03  : jz Address = 1887 3
509                                     followchain
Addr : 1884:             01  : Drop Anchor   
Addr : 1885:          05 23  : Call Sub 35   
Addr : 1887: Label003A
Addr : 1887: Label003B
510                                  return 0
Addr : 1887:             35  : Constant 1 $00000000
Addr : 1888:             33  : Return value  
Addr : 1889: JMP Label002B
Addr : 1889:          04 03  : Jmp 188E 3    
Addr : 188B: Label002C
512                                  abort(-3) ' bad argument
Addr : 188B:          37 40  : Constant Mask Y=64 Invert FFFFFFFD 4294967293
Addr : 188D:             31  : Abort value   
Addr : 188E: Label003C
Addr : 188E: Label002B
Addr : 188E: Label0020
Addr : 188E: Label0021
Addr : 188E: Label0015
448                         repeat dirptr from rootdir to rootdirend - DIRSIZE step DIRSIZE
Addr : 188E:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1890:          C8 24  : Memory Op Long VBASE + READ Address = 0024
Addr : 1892:          C8 28  : Memory Op Long VBASE + READ Address = 0028
Addr : 1894:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1896:             ED  : Math Op -     
Addr : 1897: Repeat dirptr Step Label0014
Addr : 1897:    76 06 FE B4  : Variable Operation Local Offset - 5 Assign Repeat-Var loop (pop step) Address= 174F -332
Addr : 189B: Label0016
513                         if (mode <> "w" and mode <> "a")
Addr : 189B:             68  : Variable Operation Local Offset - 2 Read
Addr : 189C:          38 77  : Constant 1 Bytes - 77 - $00000077 119
Addr : 189E:             FB  : Math Op <>    
Addr : 189F:             68  : Variable Operation Local Offset - 2 Read
Addr : 18A0:          38 61  : Constant 1 Bytes - 61 - $00000061 97
Addr : 18A2:             FB  : Math Op <>    
Addr : 18A3:             F0  : Math Op AND   
Addr : 18A4: JZ Label003D
Addr : 18A4:          0A 02  : jz Address = 18A8 2
514                            return -1 ' not found
Addr : 18A6:             34  : Constant 0 $FFFFFFFF
Addr : 18A7:             33  : Return value  
Addr : 18A8: Label003D
Addr : 18A8: Label003E
515                         direntry := freeentry
Addr : 18A8:             78  : Variable Operation Local Offset - 6 Read
Addr : 18A9:             5D  : Variable Operation Global Offset - 7 Write
516                         if (direntry == 0)
Addr : 18AA:             5C  : Variable Operation Global Offset - 7 Read
Addr : 18AB:             35  : Constant 1 $00000000
Addr : 18AC:             FC  : Math Op ==    
Addr : 18AD: JZ Label003F
Addr : 18AD:          0A 03  : jz Address = 18B2 3
517                            abort(-2) ' no empty directory entry
Addr : 18AF:          37 60  : Constant Mask Y=96 Decrement Invert FFFFFFFE 4294967294
Addr : 18B1:             31  : Abort value   
Addr : 18B2: Label003F
Addr : 18B2: Label0040
519                         s := readbytec(direntry)
Addr : 18B2:             00  : Drop Anchor Push 
Addr : 18B3:             5C  : Variable Operation Global Offset - 7 Read
Addr : 18B4:          05 21  : Call Sub 33   
Addr : 18B6:             65  : Variable Operation Local Offset - 1 Write
520                         bytefill(s, 0, DIRSIZE)
Addr : 18B7:             64  : Variable Operation Local Offset - 1 Read
Addr : 18B8:             35  : Constant 1 $00000000
Addr : 18B9:          37 04  : Constant Mask Y=4 00000020 32
Addr : 18BB:             18  : ByteFill(Start, Value, Count)
521                         bytemove(s, @padname, 11)
Addr : 18BC:             64  : Variable Operation Local Offset - 1 Read
Addr : 18BD:       8B 84 48  : Memory Op Byte VBASE + ADDRESS Address = 0448
Addr : 18C0:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 18C2:             1C  : ByteMove(To, From, Count)
522                         brwword(s+26, -1)
Addr : 18C3:             01  : Drop Anchor   
Addr : 18C4:             64  : Variable Operation Local Offset - 1 Read
Addr : 18C5:          38 1A  : Constant 1 Bytes - 1A - $0000001A 26
Addr : 18C7:             EC  : Math Op +     
Addr : 18C8:             34  : Constant 0 $FFFFFFFF
Addr : 18C9:          05 1F  : Call Sub 31   
523                         i := pdate
Addr : 18CB:             00  : Drop Anchor Push 
Addr : 18CC:          05 2A  : Call Sub 42   
Addr : 18CE:             6D  : Variable Operation Local Offset - 3 Write
524                         brwlong(s+$e, i) ' write create time and date
Addr : 18CF:             01  : Drop Anchor   
Addr : 18D0:             64  : Variable Operation Local Offset - 1 Read
Addr : 18D1:          38 0E  : Constant 1 Bytes - 0E - $0000000E 14
Addr : 18D3:             EC  : Math Op +     
Addr : 18D4:             6C  : Variable Operation Local Offset - 3 Read
Addr : 18D5:          05 20  : Call Sub 32   
525                         brwlong(s+$16, i) ' write last modified date and time
Addr : 18D7:             01  : Drop Anchor   
Addr : 18D8:             64  : Variable Operation Local Offset - 1 Read
Addr : 18D9:          38 16  : Constant 1 Bytes - 16 - $00000016 22
Addr : 18DB:             EC  : Math Op +     
Addr : 18DC:             6C  : Variable Operation Local Offset - 3 Read
Addr : 18DD:          05 20  : Call Sub 32   
526                         if (direntry == sentinel and direntry + DIRSIZE < rootdirend)
Addr : 18DF:             5C  : Variable Operation Global Offset - 7 Read
Addr : 18E0:             70  : Variable Operation Local Offset - 4 Read
Addr : 18E1:             FC  : Math Op ==    
Addr : 18E2:             5C  : Variable Operation Global Offset - 7 Read
Addr : 18E3:          37 04  : Constant Mask Y=4 00000020 32
Addr : 18E5:             EC  : Math Op +     
Addr : 18E6:          C8 28  : Memory Op Long VBASE + READ Address = 0028
Addr : 18E8:             F9  : Math Op <     
Addr : 18E9:             F0  : Math Op AND   
Addr : 18EA: JZ Label0041
Addr : 18EA:          0A 0B  : jz Address = 18F7 11
527                            brwword(readbytec(direntry+DIRSIZE), 0)
Addr : 18EC:             01  : Drop Anchor   
Addr : 18ED:             00  : Drop Anchor Push 
Addr : 18EE:             5C  : Variable Operation Global Offset - 7 Read
Addr : 18EF:          37 04  : Constant Mask Y=4 00000020 32
Addr : 18F1:             EC  : Math Op +     
Addr : 18F2:          05 21  : Call Sub 33   
Addr : 18F4:             35  : Constant 1 $00000000
Addr : 18F5:          05 1F  : Call Sub 31   
Addr : 18F7: Label0041
Addr : 18F7: Label0042
528                         flushifdirty
Addr : 18F7:             01  : Drop Anchor   
Addr : 18F8:          05 1B  : Call Sub 27   
529                         writelink := direntry + 26
Addr : 18FA:             5C  : Variable Operation Global Offset - 7 Read
Addr : 18FB:          38 1A  : Constant 1 Bytes - 1A - $0000001A 26
Addr : 18FD:             EC  : Math Op +     
Addr : 18FE:             59  : Variable Operation Global Offset - 6 Write
530                         fclust := 0
Addr : 18FF:             35  : Constant 1 $00000000
Addr : 1900:             41  : Variable Operation Global Offset - 0 Write
531                         bufend := SECTORSIZE
Addr : 1901:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1903:             55  : Variable Operation Global Offset - 5 Write
532                         return 0
Addr : 1904:             35  : Constant 1 $00000000
Addr : 1905:             33  : Return value  
Addr : 1906: Data : 32                       2
|===========================================================================|
Spin Block pread with 2 Parameters and 2 Extra Stack Longs. Method 20
pub pread(ubuf, count) | r, t

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - ubuf
Local Parameter DBASE:0008 - count
Local Variable  DBASE:000C - r
Local Variable  DBASE:0010 - t
|===========================================================================|
540                         r := 0
Addr : 1907:             35  : Constant 1 $00000000
Addr : 1908:             6D  : Variable Operation Local Offset - 3 Write
Addr : 1909: Label0003
541                         repeat while (count > 0)
Addr : 1909:             68  : Variable Operation Local Offset - 2 Read
Addr : 190A:             35  : Constant 1 $00000000
Addr : 190B:             FA  : Math Op >     
Addr : 190C: JZ Label0005
Addr : 190C:          0A 37  : jz Address = 1945 55
542                            if (bufat => bufend)
Addr : 190E:             50  : Variable Operation Global Offset - 4 Read
Addr : 190F:             54  : Variable Operation Global Offset - 5 Read
Addr : 1910:             FE  : Math Op =>    
Addr : 1911: JZ Label0006
Addr : 1911:          0A 12  : jz Address = 1925 18
543                               t := pfillbuf
Addr : 1913:             00  : Drop Anchor Push 
Addr : 1914:          05 29  : Call Sub 41   
Addr : 1916:             71  : Variable Operation Local Offset - 4 Write
544                               if (t =< 0)
Addr : 1917:             70  : Variable Operation Local Offset - 4 Read
Addr : 1918:             35  : Constant 1 $00000000
Addr : 1919:             FD  : Math Op =<    
Addr : 191A: JZ Label0008
Addr : 191A:          0A 09  : jz Address = 1925 9
545                                  if (r > 0)
Addr : 191C:             6C  : Variable Operation Local Offset - 3 Read
Addr : 191D:             35  : Constant 1 $00000000
Addr : 191E:             FA  : Math Op >     
Addr : 191F: JZ Label000A
Addr : 191F:          0A 02  : jz Address = 1923 2
546                                     return r
Addr : 1921:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1922:             33  : Return value  
Addr : 1923: Label000A
Addr : 1923: Label000B
547                                  return t
Addr : 1923:             70  : Variable Operation Local Offset - 4 Read
Addr : 1924:             33  : Return value  
Addr : 1925: Label0008
Addr : 1925: Label0009
Addr : 1925: Label0006
Addr : 1925: Label0007
548                            t := bufend - bufat
Addr : 1925:             54  : Variable Operation Global Offset - 5 Read
Addr : 1926:             50  : Variable Operation Global Offset - 4 Read
Addr : 1927:             ED  : Math Op -     
Addr : 1928:             71  : Variable Operation Local Offset - 4 Write
549                            if (t > count)
Addr : 1929:             70  : Variable Operation Local Offset - 4 Read
Addr : 192A:             68  : Variable Operation Local Offset - 2 Read
Addr : 192B:             FA  : Math Op >     
Addr : 192C: JZ Label000C
Addr : 192C:          0A 02  : jz Address = 1930 2
550                               t := count
Addr : 192E:             68  : Variable Operation Local Offset - 2 Read
Addr : 192F:             71  : Variable Operation Local Offset - 4 Write
Addr : 1930: Label000C
Addr : 1930: Label000D
551                            bytemove(ubuf, @buf+bufat, t)
Addr : 1930:             64  : Variable Operation Local Offset - 1 Read
Addr : 1931:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 1933:             50  : Variable Operation Global Offset - 4 Read
Addr : 1934:             EC  : Math Op +     
Addr : 1935:             70  : Variable Operation Local Offset - 4 Read
Addr : 1936:             1C  : ByteMove(To, From, Count)
552                            bufat += t
Addr : 1937:             70  : Variable Operation Local Offset - 4 Read
Addr : 1938:          52 4C  : Variable Operation Global Offset - 4 Assign WordMathop +
553                            r += t
Addr : 193A:             70  : Variable Operation Local Offset - 4 Read
Addr : 193B:          6E 4C  : Variable Operation Local Offset - 3 Assign WordMathop +
554                            ubuf += t
Addr : 193D:             70  : Variable Operation Local Offset - 4 Read
Addr : 193E:          66 4C  : Variable Operation Local Offset - 1 Assign WordMathop +
555                            count -= t
Addr : 1940:             70  : Variable Operation Local Offset - 4 Read
Addr : 1941:          6A 4D  : Variable Operation Local Offset - 2 Assign WordMathop -
Addr : 1943: Label0004
Addr : 1943: JMP Label0003
Addr : 1943:          04 44  : Jmp 1909 -60  
Addr : 1945: Label0005
556                         return r
Addr : 1945:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1946:             33  : Return value  
Addr : 1947: Data : 32                       2
|===========================================================================|
Spin Block pgetc with 0 Parameters and 1 Extra Stack Longs. Method 21
pub pgetc | t

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - t
|===========================================================================|
564                         if (bufat => bufend)
Addr : 1948:             50  : Variable Operation Global Offset - 4 Read
Addr : 1949:             54  : Variable Operation Global Offset - 5 Read
Addr : 194A:             FE  : Math Op =>    
Addr : 194B: JZ Label0003
Addr : 194B:          0A 0B  : jz Address = 1958 11
565                            t := pfillbuf
Addr : 194D:             00  : Drop Anchor Push 
Addr : 194E:          05 29  : Call Sub 41   
Addr : 1950:             65  : Variable Operation Local Offset - 1 Write
566                            if (t =< 0)
Addr : 1951:             64  : Variable Operation Local Offset - 1 Read
Addr : 1952:             35  : Constant 1 $00000000
Addr : 1953:             FD  : Math Op =<    
Addr : 1954: JZ Label0005
Addr : 1954:          0A 02  : jz Address = 1958 2
567                               return -1
Addr : 1956:             34  : Constant 0 $FFFFFFFF
Addr : 1957:             33  : Return value  
Addr : 1958: Label0005
Addr : 1958: Label0006
Addr : 1958: Label0003
Addr : 1958: Label0004
568                         return (buf[bufat++])
Addr : 1958:          52 AE  : Variable Operation Global Offset - 4 Assign VAR++ post inc Long Push
Addr : 195A:          98 48  : Memory Op Byte VBASE + POP Index READ Address = 0048
Addr : 195C:             33  : Return value  
Addr : 195D: Data : 32                       2
|===========================================================================|
Spin Block pwrite with 2 Parameters and 2 Extra Stack Longs. Method 22
pub pwrite(ubuf, count) | r, t

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - ubuf
Local Parameter DBASE:0008 - count
Local Variable  DBASE:000C - r
Local Variable  DBASE:0010 - t
|===========================================================================|
576                         t := 0
Addr : 195E:             35  : Constant 1 $00000000
Addr : 195F:             71  : Variable Operation Local Offset - 4 Write
Addr : 1960: Label0003
577                         repeat while (count > 0)
Addr : 1960:             68  : Variable Operation Local Offset - 2 Read
Addr : 1961:             35  : Constant 1 $00000000
Addr : 1962:             FA  : Math Op >     
Addr : 1963: JZ Label0005
Addr : 1963:          0A 2B  : jz Address = 1990 43
578                            if (bufat => bufend)
Addr : 1965:             50  : Variable Operation Global Offset - 4 Read
Addr : 1966:             54  : Variable Operation Global Offset - 5 Read
Addr : 1967:             FE  : Math Op =>    
Addr : 1968: JZ Label0006
Addr : 1968:          0A 06  : jz Address = 1970 6
579                               t := pflushbuf(bufat, 0)
Addr : 196A:             00  : Drop Anchor Push 
Addr : 196B:             50  : Variable Operation Global Offset - 4 Read
Addr : 196C:             35  : Constant 1 $00000000
Addr : 196D:          05 28  : Call Sub 40   
Addr : 196F:             71  : Variable Operation Local Offset - 4 Write
Addr : 1970: Label0006
Addr : 1970: Label0007
580                            t := bufend - bufat
Addr : 1970:             54  : Variable Operation Global Offset - 5 Read
Addr : 1971:             50  : Variable Operation Global Offset - 4 Read
Addr : 1972:             ED  : Math Op -     
Addr : 1973:             71  : Variable Operation Local Offset - 4 Write
581                            if (t > count)
Addr : 1974:             70  : Variable Operation Local Offset - 4 Read
Addr : 1975:             68  : Variable Operation Local Offset - 2 Read
Addr : 1976:             FA  : Math Op >     
Addr : 1977: JZ Label0008
Addr : 1977:          0A 02  : jz Address = 197B 2
582                               t := count
Addr : 1979:             68  : Variable Operation Local Offset - 2 Read
Addr : 197A:             71  : Variable Operation Local Offset - 4 Write
Addr : 197B: Label0008
Addr : 197B: Label0009
583                            bytemove(@buf+bufat, ubuf, t)
Addr : 197B:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 197D:             50  : Variable Operation Global Offset - 4 Read
Addr : 197E:             EC  : Math Op +     
Addr : 197F:             64  : Variable Operation Local Offset - 1 Read
Addr : 1980:             70  : Variable Operation Local Offset - 4 Read
Addr : 1981:             1C  : ByteMove(To, From, Count)
584                            r += t
Addr : 1982:             70  : Variable Operation Local Offset - 4 Read
Addr : 1983:          6E 4C  : Variable Operation Local Offset - 3 Assign WordMathop +
585                            bufat += t
Addr : 1985:             70  : Variable Operation Local Offset - 4 Read
Addr : 1986:          52 4C  : Variable Operation Global Offset - 4 Assign WordMathop +
586                            ubuf += t
Addr : 1988:             70  : Variable Operation Local Offset - 4 Read
Addr : 1989:          66 4C  : Variable Operation Local Offset - 1 Assign WordMathop +
587                            count -= t
Addr : 198B:             70  : Variable Operation Local Offset - 4 Read
Addr : 198C:          6A 4D  : Variable Operation Local Offset - 2 Assign WordMathop -
Addr : 198E: Label0004
Addr : 198E: JMP Label0003
Addr : 198E:          04 50  : Jmp 1960 -48  
Addr : 1990: Label0005
588                         return t
Addr : 1990:             70  : Variable Operation Local Offset - 4 Read
Addr : 1991:             33  : Return value  
Addr : 1992: Data : 32                       2
|===========================================================================|
Spin Block pputc with 1 Parameters and 0 Extra Stack Longs. Method 23
pub pputc(c)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - c
|===========================================================================|
595                         buf[bufat++] := c
Addr : 1993:             64  : Variable Operation Local Offset - 1 Read
Addr : 1994:          52 AE  : Variable Operation Global Offset - 4 Assign VAR++ post inc Long Push
Addr : 1996:          99 48  : Memory Op Byte VBASE + POP Index WRITE Address = 0048
596                         if (bufat == SECTORSIZE)
Addr : 1998:             50  : Variable Operation Global Offset - 4 Read
Addr : 1999:          37 08  : Constant Mask Y=8 00000200 512
Addr : 199B:             FC  : Math Op ==    
Addr : 199C: JZ Label0003
Addr : 199C:          0A 07  : jz Address = 19A5 7
597                            return pflushbuf(SECTORSIZE, 0)
Addr : 199E:             00  : Drop Anchor Push 
Addr : 199F:          37 08  : Constant Mask Y=8 00000200 512
Addr : 19A1:             35  : Constant 1 $00000000
Addr : 19A2:          05 28  : Call Sub 40   
Addr : 19A4:             33  : Return value  
Addr : 19A5: Label0003
Addr : 19A5: Label0004
598                         return 0
Addr : 19A5:             35  : Constant 1 $00000000
Addr : 19A6:             33  : Return value  
Addr : 19A7: Data : 32                       2
|===========================================================================|
Spin Block opendir with 0 Parameters and 1 Extra Stack Longs. Method 24
pub opendir | off

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - off
|===========================================================================|
605                         pclose
Addr : 19A8:             01  : Drop Anchor   
Addr : 19A9:          05 12  : Call Sub 18   
606                         off := rootdir - (dataregion << SECTORSHIFT)
Addr : 19AB:          C8 24  : Memory Op Long VBASE + READ Address = 0024
Addr : 19AD:          C8 2C  : Memory Op Long VBASE + READ Address = 002C
Addr : 19AF:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 19B1:             E3  : Math Op <<    
Addr : 19B2:             ED  : Math Op -     
Addr : 19B3:             65  : Variable Operation Local Offset - 1 Write
607                         fclust := off >> (clustershift + SECTORSHIFT)
Addr : 19B4:             64  : Variable Operation Local Offset - 1 Read
Addr : 19B5:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 19B7:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 19B9:             EC  : Math Op +     
Addr : 19BA:             E2  : Math Op >>    
Addr : 19BB:             41  : Variable Operation Global Offset - 0 Write
608                         floc := off - (fclust << (clustershift + SECTORSHIFT))
Addr : 19BC:             64  : Variable Operation Local Offset - 1 Read
Addr : 19BD:             40  : Variable Operation Global Offset - 0 Read
Addr : 19BE:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 19C0:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 19C2:             EC  : Math Op +     
Addr : 19C3:             E3  : Math Op <<    
Addr : 19C4:             ED  : Math Op -     
Addr : 19C5:             49  : Variable Operation Global Offset - 2 Write
609                         frem := rootdirend - rootdir
Addr : 19C6:          C8 28  : Memory Op Long VBASE + READ Address = 0028
Addr : 19C8:          C8 24  : Memory Op Long VBASE + READ Address = 0024
Addr : 19CA:             ED  : Math Op -     
Addr : 19CB:             4D  : Variable Operation Global Offset - 3 Write
610                         filesize := floc + frem
Addr : 19CC:             48  : Variable Operation Global Offset - 2 Read
Addr : 19CD:             4C  : Variable Operation Global Offset - 3 Read
Addr : 19CE:             EC  : Math Op +     
Addr : 19CF:             45  : Variable Operation Global Offset - 1 Write
611                         return 0
Addr : 19D0:             35  : Constant 1 $00000000
Addr : 19D1:             33  : Return value  
Addr : 19D2: Data : 32                       2
|===========================================================================|
Spin Block nextfile with 1 Parameters and 4 Extra Stack Longs. Method 25
pub nextfile(fbuf) | i, t, at, lns

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - fbuf
Local Variable  DBASE:0008 - i
Local Variable  DBASE:000C - t
Local Variable  DBASE:0010 - at
Local Variable  DBASE:0014 - lns
|===========================================================================|
620                         repeat
Addr : 19D3: Label0003
621                            if (bufat => bufend)
Addr : 19D3:             50  : Variable Operation Global Offset - 4 Read
Addr : 19D4:             54  : Variable Operation Global Offset - 5 Read
Addr : 19D5:             FE  : Math Op =>    
Addr : 19D6: JZ Label0006
Addr : 19D6:          0A 1C  : jz Address = 19F4 28
622                               t := pfillbuf
Addr : 19D8:             00  : Drop Anchor Push 
Addr : 19D9:          05 29  : Call Sub 41   
Addr : 19DB:             6D  : Variable Operation Local Offset - 3 Write
623                               if (t < 0)
Addr : 19DC:             6C  : Variable Operation Local Offset - 3 Read
Addr : 19DD:             35  : Constant 1 $00000000
Addr : 19DE:             F9  : Math Op <     
Addr : 19DF: JZ Label0008
Addr : 19DF:          0A 02  : jz Address = 19E3 2
624                                  return t
Addr : 19E1:             6C  : Variable Operation Local Offset - 3 Read
Addr : 19E2:             33  : Return value  
Addr : 19E3: Label0008
Addr : 19E3: Label0009
625                               if (((floc >> SECTORSHIFT) & ((1 << clustershift) - 1)) == 0)
Addr : 19E3:             48  : Variable Operation Global Offset - 2 Read
Addr : 19E4:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 19E6:             E2  : Math Op >>    
Addr : 19E7:             36  : Constant 2 $00000001
Addr : 19E8:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 19EA:             E3  : Math Op <<    
Addr : 19EB:             36  : Constant 2 $00000001
Addr : 19EC:             ED  : Math Op -     
Addr : 19ED:             E8  : Math Op &     
Addr : 19EE:             35  : Constant 1 $00000000
Addr : 19EF:             FC  : Math Op ==    
Addr : 19F0: JZ Label000A
Addr : 19F0:          0A 02  : jz Address = 19F4 2
626                                  fclust++            
Addr : 19F2:          42 2E  : Variable Operation Global Offset - 0 Assign VAR++ post inc Long
Addr : 19F4: Label000A
Addr : 19F4: Label000B
Addr : 19F4: Label0006
Addr : 19F4: Label0007
627                            at := @buf + bufat
Addr : 19F4:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 19F6:             50  : Variable Operation Global Offset - 4 Read
Addr : 19F7:             EC  : Math Op +     
Addr : 19F8:             71  : Variable Operation Local Offset - 4 Write
628                            if (byte[at] == 0)
Addr : 19F9:             70  : Variable Operation Local Offset - 4 Read
Addr : 19FA:             80  : Memory Op Byte POP Address READ 
Addr : 19FB:             35  : Constant 1 $00000000
Addr : 19FC:             FC  : Math Op ==    
Addr : 19FD: JZ Label000C
Addr : 19FD:          0A 02  : jz Address = 1A01 2
629                               return -1
Addr : 19FF:             34  : Constant 0 $FFFFFFFF
Addr : 1A00:             33  : Return value  
Addr : 1A01: Label000C
Addr : 1A01: Label000D
630                            bufat += DIRSIZE
Addr : 1A01:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1A03:          52 4C  : Variable Operation Global Offset - 4 Assign WordMathop +
631                            if (byte[at] <> $e5 and (byte[at][$0b] & $18) == 0)
Addr : 1A05:             70  : Variable Operation Local Offset - 4 Read
Addr : 1A06:             80  : Memory Op Byte POP Address READ 
Addr : 1A07:          38 E5  : Constant 1 Bytes - E5 - $000000E5 229
Addr : 1A09:             FB  : Math Op <>    
Addr : 1A0A:             70  : Variable Operation Local Offset - 4 Read
Addr : 1A0B:          38 0B  : Constant 1 Bytes - 0B - $0000000B 11
Addr : 1A0D:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 1A0E:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 1A10:             E8  : Math Op &     
Addr : 1A11:             35  : Constant 1 $00000000
Addr : 1A12:             FC  : Math Op ==    
Addr : 1A13:             F0  : Math Op AND   
Addr : 1A14: JZ Label000E
Addr : 1A14:          0A 39  : jz Address = 1A4F 57
632                               lns := fbuf
Addr : 1A16:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A17:             75  : Variable Operation Local Offset - 5 Write
633                               repeat i from 0 to 10
Addr : 1A18:             35  : Constant 1 $00000000
Addr : 1A19:             69  : Variable Operation Local Offset - 2 Write
Addr : 1A1A: Label0010
634                                  byte[fbuf] := byte[at][i]
Addr : 1A1A:             70  : Variable Operation Local Offset - 4 Read
Addr : 1A1B:             68  : Variable Operation Local Offset - 2 Read
Addr : 1A1C:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 1A1D:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A1E:             81  : Memory Op Byte POP Address WRITE 
635                                  fbuf++
Addr : 1A1F:          66 2E  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long
636                                  if (byte[at][i] <> " ")
Addr : 1A21:             70  : Variable Operation Local Offset - 4 Read
Addr : 1A22:             68  : Variable Operation Local Offset - 2 Read
Addr : 1A23:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 1A24:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1A26:             FB  : Math Op <>    
Addr : 1A27: JZ Label0013
Addr : 1A27:          0A 02  : jz Address = 1A2B 2
637                                     lns := fbuf
Addr : 1A29:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A2A:             75  : Variable Operation Local Offset - 5 Write
Addr : 1A2B: Label0013
Addr : 1A2B: Label0014
638                                  if (i == 7 or i == 10)
Addr : 1A2B:             68  : Variable Operation Local Offset - 2 Read
Addr : 1A2C:          37 22  : Constant Mask Y=34 Decrement 00000007 7
Addr : 1A2E:             FC  : Math Op ==    
Addr : 1A2F:             68  : Variable Operation Local Offset - 2 Read
Addr : 1A30:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 1A32:             FC  : Math Op ==    
Addr : 1A33:             F2  : Math Op OR    
Addr : 1A34: JZ Label0015
Addr : 1A34:          0A 0E  : jz Address = 1A44 14
639                                     fbuf := lns
Addr : 1A36:             74  : Variable Operation Local Offset - 5 Read
Addr : 1A37:             65  : Variable Operation Local Offset - 1 Write
640                                     if (i == 7)
Addr : 1A38:             68  : Variable Operation Local Offset - 2 Read
Addr : 1A39:          37 22  : Constant Mask Y=34 Decrement 00000007 7
Addr : 1A3B:             FC  : Math Op ==    
Addr : 1A3C: JZ Label0017
Addr : 1A3C:          0A 06  : jz Address = 1A44 6
641                                        byte[fbuf] := "."
Addr : 1A3E:          38 2E  : Constant 1 Bytes - 2E - $0000002E 46
Addr : 1A40:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A41:             81  : Memory Op Byte POP Address WRITE 
642                                        fbuf++
Addr : 1A42:          66 2E  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long
Addr : 1A44: Label0017
Addr : 1A44: Label0018
Addr : 1A44: Label0015
Addr : 1A44: Label0016
Addr : 1A44: Label0011
633                               repeat i from 0 to 10
Addr : 1A44:             35  : Constant 1 $00000000
Addr : 1A45:          38 0A  : Constant 1 Bytes - 0A - $0000000A 10
Addr : 1A47: Repeat i Step Label0010
Addr : 1A47:       6A 02 50  : Variable Operation Local Offset - 2 Assign Repeat-Var loop Address= 1A1A -48
Addr : 1A4A: Label0012
643                               byte[fbuf] := 0
Addr : 1A4A:             35  : Constant 1 $00000000
Addr : 1A4B:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A4C:             81  : Memory Op Byte POP Address WRITE 
644                               return 0
Addr : 1A4D:             35  : Constant 1 $00000000
Addr : 1A4E:             33  : Return value  
Addr : 1A4F: Label000E
Addr : 1A4F: Label000F
Addr : 1A4F: Label0004
Addr : 1A4F: JMP Label0003
Addr : 1A4F:       04 FF 81  : Jmp 19D3 -127 
Addr : 1A52: Label0005
Addr : 1A52:             32  : Return        
|===========================================================================|
Spin Block writeblock2 with 2 Parameters and 0 Extra Stack Longs. Method 26
pri writeblock2(n, b)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - n
Local Parameter DBASE:0008 - b
|===========================================================================|
148                         ldr.writeSDCard(n, b, SECTORSIZE)
Addr : 1A53:             01  : Drop Anchor   
Addr : 1A54:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A55:             68  : Variable Operation Local Offset - 2 Read
Addr : 1A56:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1A58:       06 2B 07  : Call Obj.Sub 43 7
149                         if (n => fat1 and n < fat1 + sectorsperfat)
Addr : 1A5B:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A5C:          C8 34  : Memory Op Long VBASE + READ Address = 0034
Addr : 1A5E:             FE  : Math Op =>    
Addr : 1A5F:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A60:          C8 34  : Memory Op Long VBASE + READ Address = 0034
Addr : 1A62:          C8 3C  : Memory Op Long VBASE + READ Address = 003C
Addr : 1A64:             EC  : Math Op +     
Addr : 1A65:             F9  : Math Op <     
Addr : 1A66:             F0  : Math Op AND   
Addr : 1A67: JZ Label0003
Addr : 1A67:          0A 0B  : jz Address = 1A74 11
150                            ldr.writeSDCard(n+sectorsperfat, b, SECTORSIZE)
Addr : 1A69:             01  : Drop Anchor   
Addr : 1A6A:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A6B:          C8 3C  : Memory Op Long VBASE + READ Address = 003C
Addr : 1A6D:             EC  : Math Op +     
Addr : 1A6E:             68  : Variable Operation Local Offset - 2 Read
Addr : 1A6F:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1A71:       06 2B 07  : Call Obj.Sub 43 7
Addr : 1A74: Label0003
Addr : 1A74: Label0004
Addr : 1A74:             32  : Return        
|===========================================================================|
Spin Block flushifdirty with 0 Parameters and 0 Extra Stack Longs. Method 27
pri flushifdirty

Local Parameter DBASE:0000 - Result
|===========================================================================|
156                         if (dirty)
Addr : 1A75:          C8 44  : Memory Op Long VBASE + READ Address = 0044
Addr : 1A77: JZ Label0003
Addr : 1A77:          0A 0B  : jz Address = 1A84 11
157                            writeblock2(lastread, @buf2)
Addr : 1A79:             01  : Drop Anchor   
Addr : 1A7A:          C8 40  : Memory Op Long VBASE + READ Address = 0040
Addr : 1A7C:       8B 82 48  : Memory Op Byte VBASE + ADDRESS Address = 0248
Addr : 1A7F:          05 1A  : Call Sub 26   
158                            dirty := 0
Addr : 1A81:             35  : Constant 1 $00000000
Addr : 1A82:          C9 44  : Memory Op Long VBASE + WRITE Address = 0044
Addr : 1A84: Label0003
Addr : 1A84: Label0004
Addr : 1A84:             32  : Return        
|===========================================================================|
Spin Block readblockc with 1 Parameters and 0 Extra Stack Longs. Method 28
pri readblockc(n)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - n
|===========================================================================|
165                         if (n <> lastread)
Addr : 1A85:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A86:          C8 40  : Memory Op Long VBASE + READ Address = 0040
Addr : 1A88:             FB  : Math Op <>    
Addr : 1A89: JZ Label0003
Addr : 1A89:          0A 10  : jz Address = 1A9B 16
166                            flushifdirty
Addr : 1A8B:             01  : Drop Anchor   
Addr : 1A8C:          05 1B  : Call Sub 27   
167                            ldr.readSDCard(n, @buf2, SECTORSIZE)
Addr : 1A8E:             01  : Drop Anchor   
Addr : 1A8F:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A90:       8B 82 48  : Memory Op Byte VBASE + ADDRESS Address = 0248
Addr : 1A93:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1A95:       06 2B 06  : Call Obj.Sub 43 6
168                            lastread := n
Addr : 1A98:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A99:          C9 40  : Memory Op Long VBASE + WRITE Address = 0040
Addr : 1A9B: Label0003
Addr : 1A9B: Label0004
Addr : 1A9B:             32  : Return        
|===========================================================================|
Spin Block brword with 1 Parameters and 0 Extra Stack Longs. Method 29
pri brword(b)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - b
|===========================================================================|
174                         return (byte[b]) + ((byte[b][1]) << 8)
Addr : 1A9C:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A9D:             80  : Memory Op Byte POP Address READ 
Addr : 1A9E:             64  : Variable Operation Local Offset - 1 Read
Addr : 1A9F:             36  : Constant 2 $00000001
Addr : 1AA0:             90  : Memory Op Byte POP Address POP Index READ 
Addr : 1AA1:          37 02  : Constant Mask Y=2 00000008 8
Addr : 1AA3:             E3  : Math Op <<    
Addr : 1AA4:             EC  : Math Op +     
Addr : 1AA5:             33  : Return value  
Addr : 1AA6: Data : 32                       2
|===========================================================================|
Spin Block brlong with 1 Parameters and 0 Extra Stack Longs. Method 30
pri brlong(b)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - b
|===========================================================================|
180                         return brword(b) + (brword(b+2) << 16)
Addr : 1AA7:             00  : Drop Anchor Push 
Addr : 1AA8:             64  : Variable Operation Local Offset - 1 Read
Addr : 1AA9:          05 1D  : Call Sub 29   
Addr : 1AAB:             00  : Drop Anchor Push 
Addr : 1AAC:             64  : Variable Operation Local Offset - 1 Read
Addr : 1AAD:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1AAF:             EC  : Math Op +     
Addr : 1AB0:          05 1D  : Call Sub 29   
Addr : 1AB2:          37 03  : Constant Mask Y=3 00000010 16
Addr : 1AB4:             E3  : Math Op <<    
Addr : 1AB5:             EC  : Math Op +     
Addr : 1AB6:             33  : Return value  
Addr : 1AB7: Data : 32                       2
|===========================================================================|
Spin Block brwword with 2 Parameters and 0 Extra Stack Longs. Method 31
pri brwword(w, v)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - w
Local Parameter DBASE:0008 - v
|===========================================================================|
187                         byte[w++] := v
Addr : 1AB8:             68  : Variable Operation Local Offset - 2 Read
Addr : 1AB9:          66 AE  : Variable Operation Local Offset - 1 Assign VAR++ post inc Long Push
Addr : 1ABB:             81  : Memory Op Byte POP Address WRITE 
188                         byte[w] := v >> 8
Addr : 1ABC:             68  : Variable Operation Local Offset - 2 Read
Addr : 1ABD:          37 02  : Constant Mask Y=2 00000008 8
Addr : 1ABF:             E2  : Math Op >>    
Addr : 1AC0:             64  : Variable Operation Local Offset - 1 Read
Addr : 1AC1:             81  : Memory Op Byte POP Address WRITE 
189                         dirty := 1
Addr : 1AC2:             36  : Constant 2 $00000001
Addr : 1AC3:          C9 44  : Memory Op Long VBASE + WRITE Address = 0044
Addr : 1AC5:             32  : Return        
|===========================================================================|
Spin Block brwlong with 2 Parameters and 0 Extra Stack Longs. Method 32
pri brwlong(w, v)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - w
Local Parameter DBASE:0008 - v
|===========================================================================|
196                         brwword(w, v)
Addr : 1AC6:             01  : Drop Anchor   
Addr : 1AC7:             64  : Variable Operation Local Offset - 1 Read
Addr : 1AC8:             68  : Variable Operation Local Offset - 2 Read
Addr : 1AC9:          05 1F  : Call Sub 31   
197                         brwword(w+2, v >> 16)
Addr : 1ACB:             01  : Drop Anchor   
Addr : 1ACC:             64  : Variable Operation Local Offset - 1 Read
Addr : 1ACD:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1ACF:             EC  : Math Op +     
Addr : 1AD0:             68  : Variable Operation Local Offset - 2 Read
Addr : 1AD1:          37 03  : Constant Mask Y=3 00000010 16
Addr : 1AD3:             E2  : Math Op >>    
Addr : 1AD4:          05 1F  : Call Sub 31   
Addr : 1AD6:             32  : Return        
|===========================================================================|
Spin Block readbytec with 1 Parameters and 0 Extra Stack Longs. Method 33
pri readbytec(byteloc)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - byteloc
|===========================================================================|
251                         readblockc(byteloc >> SECTORSHIFT)
Addr : 1AD7:             01  : Drop Anchor   
Addr : 1AD8:             64  : Variable Operation Local Offset - 1 Read
Addr : 1AD9:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 1ADB:             E2  : Math Op >>    
Addr : 1ADC:          05 1C  : Call Sub 28   
252                         return @buf2 + (byteloc & constant(SECTORSIZE - 1))
Addr : 1ADE:       8B 82 48  : Memory Op Byte VBASE + ADDRESS Address = 0248
Addr : 1AE1:             64  : Variable Operation Local Offset - 1 Read
Addr : 1AE2:          37 28  : Constant Mask Y=40 Decrement 000001FF 511
Addr : 1AE4:             E8  : Math Op &     
Addr : 1AE5:             EC  : Math Op +     
Addr : 1AE6:             33  : Return value  
Addr : 1AE7: Data : 32                       2
|===========================================================================|
Spin Block readfat with 1 Parameters and 0 Extra Stack Longs. Method 34
pri readfat(clust)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - clust
|===========================================================================|
259                         fatptr := (fat1 << SECTORSHIFT) + (clust << 1)
Addr : 1AE8:          C8 34  : Memory Op Long VBASE + READ Address = 0034
Addr : 1AEA:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 1AEC:             E3  : Math Op <<    
Addr : 1AED:             64  : Variable Operation Local Offset - 1 Read
Addr : 1AEE:             36  : Constant 2 $00000001
Addr : 1AEF:             E3  : Math Op <<    
Addr : 1AF0:             EC  : Math Op +     
Addr : 1AF1:          C9 20  : Memory Op Long VBASE + WRITE Address = 0020
260                         return readbytec(fatptr)
Addr : 1AF3:             00  : Drop Anchor Push 
Addr : 1AF4:          C8 20  : Memory Op Long VBASE + READ Address = 0020
Addr : 1AF6:          05 21  : Call Sub 33   
Addr : 1AF8:             33  : Return value  
Addr : 1AF9: Data : 32                       2
|===========================================================================|
Spin Block followchain with 0 Parameters and 1 Extra Stack Longs. Method 35
pri followchain | clust

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - clust
|===========================================================================|
266                         clust := brword(readfat(fclust))
Addr : 1AFA:             00  : Drop Anchor Push 
Addr : 1AFB:             00  : Drop Anchor Push 
Addr : 1AFC:             40  : Variable Operation Global Offset - 0 Read
Addr : 1AFD:          05 22  : Call Sub 34   
Addr : 1AFF:          05 1D  : Call Sub 29   
Addr : 1B01:             65  : Variable Operation Local Offset - 1 Write
267                         writelink := fatptr
Addr : 1B02:          C8 20  : Memory Op Long VBASE + READ Address = 0020
Addr : 1B04:             59  : Variable Operation Global Offset - 6 Write
268                         return clust
Addr : 1B05:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B06:             33  : Return value  
Addr : 1B07: Data : 32                       2
|===========================================================================|
Spin Block nextcluster with 0 Parameters and 1 Extra Stack Longs. Method 36
pri nextcluster | clust

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - clust
|===========================================================================|
276                         clust := followchain
Addr : 1B08:             00  : Drop Anchor Push 
Addr : 1B09:          05 23  : Call Sub 35   
Addr : 1B0B:             65  : Variable Operation Local Offset - 1 Write
277                         if (clust < 2 or clust => totclusters)
Addr : 1B0C:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B0D:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1B0F:             F9  : Math Op <     
Addr : 1B10:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B11:          C8 38  : Memory Op Long VBASE + READ Address = 0038
Addr : 1B13:             FE  : Math Op =>    
Addr : 1B14:             F2  : Math Op OR    
Addr : 1B15: JZ Label0003
Addr : 1B15:          0A 03  : jz Address = 1B1A 3
278                            abort(-9) ' bad cluster value
Addr : 1B17:          37 42  : Constant Mask Y=66 Invert FFFFFFF7 4294967287
Addr : 1B19:             31  : Abort value   
Addr : 1B1A: Label0003
Addr : 1B1A: Label0004
279                         return clust
Addr : 1B1A:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B1B:             33  : Return value  
Addr : 1B1C: Data : 32                       2
|===========================================================================|
Spin Block freeclusters with 1 Parameters and 1 Extra Stack Longs. Method 37
pri freeclusters(clust) | bp

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - clust
Local Variable  DBASE:0008 - bp
|===========================================================================|
286                         repeat while (clust < $fff0)
Addr : 1B1D: Label0003
Addr : 1B1D:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B1E:       39 FF F0  : Constant 2 Bytes - FF F0 - $0000FFF0 65520
Addr : 1B21:             F9  : Math Op <     
Addr : 1B22: JZ Label0005
Addr : 1B22:          0A 1B  : jz Address = 1B3F 27
287                            if (clust < 2)
Addr : 1B24:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B25:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1B27:             F9  : Math Op <     
Addr : 1B28: JZ Label0006
Addr : 1B28:          0A 04  : jz Address = 1B2E 4
288                               abort(-26) ' bad cluster number")
Addr : 1B2A:          38 19  : Constant 1 Bytes - 19 - $00000019 25
Addr : 1B2C:             E7  : Math Op !     
Addr : 1B2D:             31  : Abort value   
Addr : 1B2E: Label0006
Addr : 1B2E: Label0007
289                            bp := readfat(clust)
Addr : 1B2E:             00  : Drop Anchor Push 
Addr : 1B2F:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B30:          05 22  : Call Sub 34   
Addr : 1B32:             69  : Variable Operation Local Offset - 2 Write
290                            clust := brword(bp)
Addr : 1B33:             00  : Drop Anchor Push 
Addr : 1B34:             68  : Variable Operation Local Offset - 2 Read
Addr : 1B35:          05 1D  : Call Sub 29   
Addr : 1B37:             65  : Variable Operation Local Offset - 1 Write
291                            brwword(bp, 0)
Addr : 1B38:             01  : Drop Anchor   
Addr : 1B39:             68  : Variable Operation Local Offset - 2 Read
Addr : 1B3A:             35  : Constant 1 $00000000
Addr : 1B3B:          05 1F  : Call Sub 31   
Addr : 1B3D: Label0004
Addr : 1B3D: JMP Label0003
Addr : 1B3D:          04 5E  : Jmp 1B1D -34  
Addr : 1B3F: Label0005
292                         flushifdirty
Addr : 1B3F:             01  : Drop Anchor   
Addr : 1B40:          05 1B  : Call Sub 27   
Addr : 1B42:             32  : Return        
|===========================================================================|
Spin Block datablock with 0 Parameters and 0 Extra Stack Longs. Method 38
pri datablock

Local Parameter DBASE:0000 - Result
|===========================================================================|
298                         return (fclust << clustershift) + dataregion + ((floc >> SECTORSHIFT) & ((1 << clustershift) - 1))
Addr : 1B43:             40  : Variable Operation Global Offset - 0 Read
Addr : 1B44:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 1B46:             E3  : Math Op <<    
Addr : 1B47:          C8 2C  : Memory Op Long VBASE + READ Address = 002C
Addr : 1B49:             EC  : Math Op +     
Addr : 1B4A:             48  : Variable Operation Global Offset - 2 Read
Addr : 1B4B:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 1B4D:             E2  : Math Op >>    
Addr : 1B4E:             36  : Constant 2 $00000001
Addr : 1B4F:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 1B51:             E3  : Math Op <<    
Addr : 1B52:             36  : Constant 2 $00000001
Addr : 1B53:             ED  : Math Op -     
Addr : 1B54:             E8  : Math Op &     
Addr : 1B55:             EC  : Math Op +     
Addr : 1B56:             33  : Return value  
Addr : 1B57: Data : 32                       2
|===========================================================================|
Spin Block uc with 1 Parameters and 0 Extra Stack Longs. Method 39
pri uc(c)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - c
|===========================================================================|
304                         if ("a" =< c and c =< "z")
Addr : 1B58:          38 61  : Constant 1 Bytes - 61 - $00000061 97
Addr : 1B5A:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B5B:             FD  : Math Op =<    
Addr : 1B5C:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B5D:          38 7A  : Constant 1 Bytes - 7A - $0000007A 122
Addr : 1B5F:             FD  : Math Op =<    
Addr : 1B60:             F0  : Math Op AND   
Addr : 1B61: JZ Label0003
Addr : 1B61:          0A 05  : jz Address = 1B68 5
305                            return c - 32
Addr : 1B63:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B64:          37 04  : Constant Mask Y=4 00000020 32
Addr : 1B66:             ED  : Math Op -     
Addr : 1B67:             33  : Return value  
Addr : 1B68: Label0003
Addr : 1B68: Label0004
306                         return c
Addr : 1B68:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B69:             33  : Return value  
Addr : 1B6A: Data : 32                       2
|===========================================================================|
Spin Block pflushbuf with 2 Parameters and 4 Extra Stack Longs. Method 40
pri pflushbuf(r, metadata) | cluststart, newcluster, count, i

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - r
Local Parameter DBASE:0008 - metadata
Local Variable  DBASE:000C - cluststart
Local Variable  DBASE:0010 - newcluster
Local Variable  DBASE:0014 - count
Local Variable  DBASE:0018 - i
|===========================================================================|
315                         if (direntry == 0)
Addr : 1B6B:             5C  : Variable Operation Global Offset - 7 Read
Addr : 1B6C:             35  : Constant 1 $00000000
Addr : 1B6D:             FC  : Math Op ==    
Addr : 1B6E: JZ Label0003
Addr : 1B6E:          0A 04  : jz Address = 1B74 4
316                            abort(-27) ' not open for writing
Addr : 1B70:          38 1A  : Constant 1 Bytes - 1A - $0000001A 26
Addr : 1B72:             E7  : Math Op !     
Addr : 1B73:             31  : Abort value   
Addr : 1B74: Label0003
Addr : 1B74: Label0004
317                         if (r > 0) ' must *not* allocate cluster if flushing an empty buffer
Addr : 1B74:             64  : Variable Operation Local Offset - 1 Read
Addr : 1B75:             35  : Constant 1 $00000000
Addr : 1B76:             FA  : Math Op >     
Addr : 1B77: JZ Label0005
Addr : 1B77:       0A 80 AC  : jz Address = 1C26 172
318                            if (frem < SECTORSIZE)
Addr : 1B7A:             4C  : Variable Operation Global Offset - 3 Read
Addr : 1B7B:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1B7D:             F9  : Math Op <     
Addr : 1B7E: JZ Label0007
Addr : 1B7E:       0A 80 82  : jz Address = 1C03 130
321                               newcluster := -1
Addr : 1B81:             34  : Constant 0 $FFFFFFFF
Addr : 1B82:             71  : Variable Operation Local Offset - 4 Write
322                               cluststart := fclust & constant(!((SECTORSIZE >> 1) - 1))
Addr : 1B83:             40  : Variable Operation Global Offset - 0 Read
Addr : 1B84:          37 67  : Constant Mask Y=103 Decrement Invert FFFFFF00 4294967040
Addr : 1B86:             E8  : Math Op &     
Addr : 1B87:             6D  : Variable Operation Local Offset - 3 Write
323                               count := 2
Addr : 1B88:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1B8A:             75  : Variable Operation Local Offset - 5 Write
Addr : 1B8B: Label0009
325                                  readfat(cluststart)
Addr : 1B8B:             01  : Drop Anchor   
Addr : 1B8C:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1B8D:          05 22  : Call Sub 34   
326                                  repeat i from 0 to constant(SECTORSIZE - 2) step 2
Addr : 1B8F:             35  : Constant 1 $00000000
Addr : 1B90:             79  : Variable Operation Local Offset - 6 Write
Addr : 1B91: Label000C
327                                     if (buf2[i]==0 and buf2[i+1]==0)
Addr : 1B91:             78  : Variable Operation Local Offset - 6 Read
Addr : 1B92:       98 82 48  : Memory Op Byte VBASE + POP Index READ Address = 0248
Addr : 1B95:             35  : Constant 1 $00000000
Addr : 1B96:             FC  : Math Op ==    
Addr : 1B97:             78  : Variable Operation Local Offset - 6 Read
Addr : 1B98:             36  : Constant 2 $00000001
Addr : 1B99:             EC  : Math Op +     
Addr : 1B9A:       98 82 48  : Memory Op Byte VBASE + POP Index READ Address = 0248
Addr : 1B9D:             35  : Constant 1 $00000000
Addr : 1B9E:             FC  : Math Op ==    
Addr : 1B9F:             F0  : Math Op AND   
Addr : 1BA0: JZ Label000F
Addr : 1BA0:          0A 02  : jz Address = 1BA4 2
328                                        quit
Addr : 1BA2: JMP Label000E
Addr : 1BA2:          04 09  : Jmp 1BAD 9    
Addr : 1BA4: Label000F
Addr : 1BA4: Label0010
Addr : 1BA4: Label000D
326                                  repeat i from 0 to constant(SECTORSIZE - 2) step 2
Addr : 1BA4:          37 00  : Constant Mask Y=0 00000002 2
Addr : 1BA6:             35  : Constant 1 $00000000
Addr : 1BA7:       39 01 FE  : Constant 2 Bytes - 01 FE - $000001FE 510
Addr : 1BAA: Repeat i Step Label000C
Addr : 1BAA:       7A 06 64  : Variable Operation Local Offset - 6 Assign Repeat-Var loop (pop step) Address= 1B91 -28
Addr : 1BAD: Label000E
329                                  if (i < SECTORSIZE)
Addr : 1BAD:             78  : Variable Operation Local Offset - 6 Read
Addr : 1BAE:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1BB0:             F9  : Math Op <     
Addr : 1BB1: JZ Label0011
Addr : 1BB1:          0A 0E  : jz Address = 1BC1 14
330                                     newcluster := cluststart + (i >> 1)
Addr : 1BB3:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1BB4:             78  : Variable Operation Local Offset - 6 Read
Addr : 1BB5:             36  : Constant 2 $00000001
Addr : 1BB6:             E2  : Math Op >>    
Addr : 1BB7:             EC  : Math Op +     
Addr : 1BB8:             71  : Variable Operation Local Offset - 4 Write
331                                     if (newcluster => totclusters)
Addr : 1BB9:             70  : Variable Operation Local Offset - 4 Read
Addr : 1BBA:          C8 38  : Memory Op Long VBASE + READ Address = 0038
Addr : 1BBC:             FE  : Math Op =>    
Addr : 1BBD: JZ Label0013
Addr : 1BBD:          0A 02  : jz Address = 1BC1 2
332                                        newcluster := -1
Addr : 1BBF:             34  : Constant 0 $FFFFFFFF
Addr : 1BC0:             71  : Variable Operation Local Offset - 4 Write
Addr : 1BC1: Label0013
Addr : 1BC1: Label0014
Addr : 1BC1: Label0011
Addr : 1BC1: Label0012
333                                  if (newcluster > 1)
Addr : 1BC1:             70  : Variable Operation Local Offset - 4 Read
Addr : 1BC2:             36  : Constant 2 $00000001
Addr : 1BC3:             FA  : Math Op >     
Addr : 1BC4: JZ Label0015
Addr : 1BC4:          0A 22  : jz Address = 1BE8 34
334                                     brwword(@buf2+i, -1)
Addr : 1BC6:             01  : Drop Anchor   
Addr : 1BC7:       8B 82 48  : Memory Op Byte VBASE + ADDRESS Address = 0248
Addr : 1BCA:             78  : Variable Operation Local Offset - 6 Read
Addr : 1BCB:             EC  : Math Op +     
Addr : 1BCC:             34  : Constant 0 $FFFFFFFF
Addr : 1BCD:          05 1F  : Call Sub 31   
335                                     brwword(readbytec(writelink), newcluster)
Addr : 1BCF:             01  : Drop Anchor   
Addr : 1BD0:             00  : Drop Anchor Push 
Addr : 1BD1:             58  : Variable Operation Global Offset - 6 Read
Addr : 1BD2:          05 21  : Call Sub 33   
Addr : 1BD4:             70  : Variable Operation Local Offset - 4 Read
Addr : 1BD5:          05 1F  : Call Sub 31   
336                                     writelink := fatptr + i
Addr : 1BD7:          C8 20  : Memory Op Long VBASE + READ Address = 0020
Addr : 1BD9:             78  : Variable Operation Local Offset - 6 Read
Addr : 1BDA:             EC  : Math Op +     
Addr : 1BDB:             59  : Variable Operation Global Offset - 6 Write
337                                     fclust := newcluster
Addr : 1BDC:             70  : Variable Operation Local Offset - 4 Read
Addr : 1BDD:             41  : Variable Operation Global Offset - 0 Write
338                                     frem := SECTORSIZE << clustershift
Addr : 1BDE:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1BE0:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 1BE2:             E3  : Math Op <<    
Addr : 1BE3:             4D  : Variable Operation Global Offset - 3 Write
339                                     quit
Addr : 1BE4: JMP Label000B
Addr : 1BE4:          04 1D  : Jmp 1C03 29   
Addr : 1BE6: JMP Label0016
Addr : 1BE6:          04 18  : Jmp 1C00 24   
Addr : 1BE8: Label0015
341                                     cluststart += constant(SECTORSIZE >> 1)
Addr : 1BE8:          37 07  : Constant Mask Y=7 00000100 256
Addr : 1BEA:          6E 4C  : Variable Operation Local Offset - 3 Assign WordMathop +
342                                     if (cluststart => totclusters)
Addr : 1BEC:             6C  : Variable Operation Local Offset - 3 Read
Addr : 1BED:          C8 38  : Memory Op Long VBASE + READ Address = 0038
Addr : 1BEF:             FE  : Math Op =>    
Addr : 1BF0: JZ Label0018
Addr : 1BF0:          0A 0E  : jz Address = 1C00 14
343                                        cluststart := 0
Addr : 1BF2:             35  : Constant 1 $00000000
Addr : 1BF3:             6D  : Variable Operation Local Offset - 3 Write
344                                        count--
Addr : 1BF4:          76 3E  : Variable Operation Local Offset - 5 Assign VAR-- post-dec Long
345                                        if (count < 0)
Addr : 1BF6:             74  : Variable Operation Local Offset - 5 Read
Addr : 1BF7:             35  : Constant 1 $00000000
Addr : 1BF8:             F9  : Math Op <     
Addr : 1BF9: JZ Label001A
Addr : 1BF9:          0A 05  : jz Address = 1C00 5
346                                           r := -5 ' No space left on device
Addr : 1BFB:          37 41  : Constant Mask Y=65 Invert FFFFFFFB 4294967291
Addr : 1BFD:             65  : Variable Operation Local Offset - 1 Write
347                                           quit
Addr : 1BFE: JMP Label000B
Addr : 1BFE:          04 03  : Jmp 1C03 3    
Addr : 1C00: Label001A
Addr : 1C00: Label001B
Addr : 1C00: Label0018
Addr : 1C00: Label0019
Addr : 1C00: Label0017
Addr : 1C00: Label0016
Addr : 1C00: Label000A
Addr : 1C00: JMP Label0009
Addr : 1C00:       04 FF 88  : Jmp 1B8B -120 
Addr : 1C03: Label000B
Addr : 1C03: Label0007
Addr : 1C03: Label0008
348                            if (frem => SECTORSIZE)
Addr : 1C03:             4C  : Variable Operation Global Offset - 3 Read
Addr : 1C04:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1C06:             FE  : Math Op =>    
Addr : 1C07: JZ Label001C
Addr : 1C07:          0A 1D  : jz Address = 1C26 29
349                               ldr.writeSDCard(datablock, @buf, SECTORSIZE)
Addr : 1C09:             01  : Drop Anchor   
Addr : 1C0A:             00  : Drop Anchor Push 
Addr : 1C0B:          05 26  : Call Sub 38   
Addr : 1C0D:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 1C0F:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1C11:       06 2B 07  : Call Obj.Sub 43 7
350                               if (r == SECTORSIZE) ' full buffer, clear it
Addr : 1C14:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C15:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1C17:             FC  : Math Op ==    
Addr : 1C18: JZ Label001E
Addr : 1C18:          0A 0C  : jz Address = 1C26 12
351                                  floc += r
Addr : 1C1A:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C1B:          4A 4C  : Variable Operation Global Offset - 2 Assign WordMathop +
352                                  frem -= r
Addr : 1C1D:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C1E:          4E 4D  : Variable Operation Global Offset - 3 Assign WordMathop -
353                                  bufat := 0
Addr : 1C20:             35  : Constant 1 $00000000
Addr : 1C21:             51  : Variable Operation Global Offset - 4 Write
354                                  bufend := r
Addr : 1C22:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C23:             55  : Variable Operation Global Offset - 5 Write
Addr : 1C24: JMP Label001F
Addr : 1C24:          04 00  : Jmp 1C26 0    
Addr : 1C26: Label001E
Addr : 1C26: Label0020
Addr : 1C26: Label001F
Addr : 1C26: Label001C
Addr : 1C26: Label001D
Addr : 1C26: Label0005
Addr : 1C26: Label0006
357                         if (r < 0 or metadata) ' update metadata even if error
Addr : 1C26:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C27:             35  : Constant 1 $00000000
Addr : 1C28:             F9  : Math Op <     
Addr : 1C29:             68  : Variable Operation Local Offset - 2 Read
Addr : 1C2A:             F2  : Math Op OR    
Addr : 1C2B: JZ Label0021
Addr : 1C2B:          0A 1B  : jz Address = 1C48 27
358                            readblockc(direntry >> SECTORSHIFT) ' flushes unwritten FAT too
Addr : 1C2D:             01  : Drop Anchor   
Addr : 1C2E:             5C  : Variable Operation Global Offset - 7 Read
Addr : 1C2F:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 1C31:             E2  : Math Op >>    
Addr : 1C32:          05 1C  : Call Sub 28   
359                            brwlong(@buf2+(direntry & constant(SECTORSIZE-1))+28, floc+bufat)
Addr : 1C34:             01  : Drop Anchor   
Addr : 1C35:       8B 82 48  : Memory Op Byte VBASE + ADDRESS Address = 0248
Addr : 1C38:             5C  : Variable Operation Global Offset - 7 Read
Addr : 1C39:          37 28  : Constant Mask Y=40 Decrement 000001FF 511
Addr : 1C3B:             E8  : Math Op &     
Addr : 1C3C:             EC  : Math Op +     
Addr : 1C3D:          38 1C  : Constant 1 Bytes - 1C - $0000001C 28
Addr : 1C3F:             EC  : Math Op +     
Addr : 1C40:             48  : Variable Operation Global Offset - 2 Read
Addr : 1C41:             50  : Variable Operation Global Offset - 4 Read
Addr : 1C42:             EC  : Math Op +     
Addr : 1C43:          05 20  : Call Sub 32   
360                            flushifdirty
Addr : 1C45:             01  : Drop Anchor   
Addr : 1C46:          05 1B  : Call Sub 27   
Addr : 1C48: Label0021
Addr : 1C48: Label0022
361                         if (r < 0)
Addr : 1C48:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C49:             35  : Constant 1 $00000000
Addr : 1C4A:             F9  : Math Op <     
Addr : 1C4B: JZ Label0023
Addr : 1C4B:          0A 02  : jz Address = 1C4F 2
362                            abort(r)
Addr : 1C4D:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C4E:             31  : Abort value   
Addr : 1C4F: Label0023
Addr : 1C4F: Label0024
363                         return r
Addr : 1C4F:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C50:             33  : Return value  
Addr : 1C51: Data : 32                       2
|===========================================================================|
Spin Block pfillbuf with 0 Parameters and 1 Extra Stack Longs. Method 41
pri pfillbuf | r

Local Parameter DBASE:0000 - Result
Local Variable  DBASE:0004 - r
|===========================================================================|
378                         if (floc => filesize)
Addr : 1C52:             48  : Variable Operation Global Offset - 2 Read
Addr : 1C53:             44  : Variable Operation Global Offset - 1 Read
Addr : 1C54:             FE  : Math Op =>    
Addr : 1C55: JZ Label0003
Addr : 1C55:          0A 02  : jz Address = 1C59 2
379                            return -1
Addr : 1C57:             34  : Constant 0 $FFFFFFFF
Addr : 1C58:             33  : Return value  
Addr : 1C59: Label0003
Addr : 1C59: Label0004
380                         if (frem == 0)
Addr : 1C59:             4C  : Variable Operation Global Offset - 3 Read
Addr : 1C5A:             35  : Constant 1 $00000000
Addr : 1C5B:             FC  : Math Op ==    
Addr : 1C5C: JZ Label0005
Addr : 1C5C:          0A 15  : jz Address = 1C73 21
381                            fclust := nextcluster
Addr : 1C5E:             00  : Drop Anchor Push 
Addr : 1C5F:          05 24  : Call Sub 36   
Addr : 1C61:             41  : Variable Operation Global Offset - 0 Write
382                            frem := SECTORSIZE << clustershift
Addr : 1C62:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1C64:          C8 30  : Memory Op Long VBASE + READ Address = 0030
Addr : 1C66:             E3  : Math Op <<    
Addr : 1C67:             4D  : Variable Operation Global Offset - 3 Write
383                            if (frem + floc > filesize)
Addr : 1C68:             4C  : Variable Operation Global Offset - 3 Read
Addr : 1C69:             48  : Variable Operation Global Offset - 2 Read
Addr : 1C6A:             EC  : Math Op +     
Addr : 1C6B:             44  : Variable Operation Global Offset - 1 Read
Addr : 1C6C:             FA  : Math Op >     
Addr : 1C6D: JZ Label0007
Addr : 1C6D:          0A 04  : jz Address = 1C73 4
384                               frem := filesize - floc
Addr : 1C6F:             44  : Variable Operation Global Offset - 1 Read
Addr : 1C70:             48  : Variable Operation Global Offset - 2 Read
Addr : 1C71:             ED  : Math Op -     
Addr : 1C72:             4D  : Variable Operation Global Offset - 3 Write
Addr : 1C73: Label0007
Addr : 1C73: Label0008
Addr : 1C73: Label0005
Addr : 1C73: Label0006
385                         ldr.readSDCard(datablock, @buf, SECTORSIZE)
Addr : 1C73:             01  : Drop Anchor   
Addr : 1C74:             00  : Drop Anchor Push 
Addr : 1C75:          05 26  : Call Sub 38   
Addr : 1C77:          8B 48  : Memory Op Byte VBASE + ADDRESS Address = 0048
Addr : 1C79:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1C7B:       06 2B 06  : Call Obj.Sub 43 6
386                         r := SECTORSIZE
Addr : 1C7E:          37 08  : Constant Mask Y=8 00000200 512
Addr : 1C80:             65  : Variable Operation Local Offset - 1 Write
387                         if (floc + r => filesize)
Addr : 1C81:             48  : Variable Operation Global Offset - 2 Read
Addr : 1C82:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C83:             EC  : Math Op +     
Addr : 1C84:             44  : Variable Operation Global Offset - 1 Read
Addr : 1C85:             FE  : Math Op =>    
Addr : 1C86: JZ Label0009
Addr : 1C86:          0A 04  : jz Address = 1C8C 4
388                            r := filesize - floc
Addr : 1C88:             44  : Variable Operation Global Offset - 1 Read
Addr : 1C89:             48  : Variable Operation Global Offset - 2 Read
Addr : 1C8A:             ED  : Math Op -     
Addr : 1C8B:             65  : Variable Operation Local Offset - 1 Write
Addr : 1C8C: Label0009
Addr : 1C8C: Label000A
389                         floc += r
Addr : 1C8C:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C8D:          4A 4C  : Variable Operation Global Offset - 2 Assign WordMathop +
390                         frem -= r
Addr : 1C8F:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C90:          4E 4D  : Variable Operation Global Offset - 3 Assign WordMathop -
391                         bufat := 0
Addr : 1C92:             35  : Constant 1 $00000000
Addr : 1C93:             51  : Variable Operation Global Offset - 4 Write
392                         bufend := r
Addr : 1C94:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C95:             55  : Variable Operation Global Offset - 5 Write
393                         return r
Addr : 1C96:             64  : Variable Operation Local Offset - 1 Read
Addr : 1C97:             33  : Return value  
Addr : 1C98: Data : 32                       2
|===========================================================================|
Spin Block pdate with 0 Parameters and 0 Extra Stack Longs. Method 42
pri pdate

Local Parameter DBASE:0000 - Result
|===========================================================================|
421                         return constant(((2007-1980) << 25) + (1 << 21) + (6 << 16) + (12 << 11))
Addr : 1C99: 3B 36 26 60 00  : Constant 4 Bytes - 36 26 60 00 - $36266000 908484608
Addr : 1C9E:             33  : Return value  
Addr : 1C9F: Data : 32                       2
|===========================================================================|
Object sdspiFemto
Object Base is 1CA0
|===========================================================================|
Object Constants
|===========================================================================|
|===========================================================================|
VBASE Global Variables
|===========================================================================|
VBASE : 0000 LONG Size 0004 Variable cog
VBASE : 0004 LONG Size 0004 Variable control
|===========================================================================|
Object DAT Blocks
|===========================================================================|
1CD4(0000)             |                         org     0
1CD4(0000) D7 95 BF A0 | i2cEntryPoint           mov     i2cTemp,i2cPause
1CD8(0001) F1 95 BF 80 |                         add     i2cTemp,CNT             ' Wait 10us before checking
1CDC(0002) 00 94 FF F8 |                         waitcnt i2cTemp,#0
1CE0(0003) F0 9B BF 08 | i2cNewOpFetch           rdlong  i2cAddr,PAR             ' Fetch control information
1CE4(0004) CD 91 BF A0 |                         mov     i2cCmd,i2cAddr
1CE8(0005) 18 90 FF 28 |                         shr     i2cCmd,#24              ' Isolate command code
1CEC(0006) C8 B9 BF A0 |                         mov     Options,i2cCmd
1CF0(0007) B5 9B BF 60 |                         and     i2cAddr,i2cAddrMask     ' Only need address at this point
1CF4(0008) 1F 90 FF 62 |                         and     i2cCmd,#ioCmdMask  wz
1CF8(0009) 00 00 68 5C |                 if_z    jmp     #i2cEntryPoint          ' Wait for a new operation
1CFC(000A) F0 95 BF A0 |                         mov     i2cTemp,PAR
1D00(000B) 04 94 FF 80 |                         add     i2cTemp,#4              ' Now get 2nd long of packet
1D04(000C) CA 97 BF 08 |                         rdlong  i2cCount,i2cTemp
1D08(000D) CB 99 BF A0 |                         mov     i2cBufAdr,i2cCount      ' Byte count
1D0C(000E) 00 B0 FF 08 |                         rdlong  SaveClkFreq,#clkfreqVal ' Save clock frequency and mode
1D10(000F) 10 96 FF 28 |                         shr     i2cCount,#16
1D14(0010) B4 99 BF 60 |                         and     i2cBufAdr,i2cWordMask   ' HUB RAM address of buffer
1D18(0011) 04 B2 FF 00 |                         rdbyte  SaveClkMode,#clksetVal
1D1C(0012) 00 EC FE 50 |                         movs    ShiftData,#0            ' Initialize for saving Preamble
1D20(0013) BD EF BE A0 |                         mov     StoreLocal,initStore    '  on I2C and SPI reads
1D24(0014) 00 84 FF A0 |                         mov     Preamble+0,#0
1D28(0015) 00 86 FF A0 |                         mov     Preamble+1,#0
1D2C(0016) 00 88 FF A0 |                         mov     Preamble+2,#0
1D30(0017) 00 8A FF A0 |                         mov     Preamble+3,#0
1D34(0018) EC B6 FF A0 |                         mov     CheckSum,#$EC           ' Adjust checksum for stack marker
1D38(0019) 20 B8 7F 61 |                         test    Options,#ioNoStore wc
1D3C(001A) 08 90 7F 62 |                         test    i2cCmd,#ioBootCmd  wz
1D40(001B) C8 95 87 A0 |          if_nz_and_nc   mov     i2cTemp,i2cCmd          ' Stop the caller's COG unless
1D44(001C) 07 94 C7 60 |          if_nz_and_nc   and     i2cTemp,#%111           '  it's this one
1D48(001D) 01 8E C7 0C |          if_nz_and_nc   cogid   i2cCogId
1D4C(001E) CA 8F 07 86 |          if_nz_and_nc   cmp     i2cCogId,i2cTemp   wz
1D50(001F) 03 94 47 0C |          if_nz_and_nc   cogstop i2cTemp
1D54(0020) 10 90 7F 62 |                         test    i2cCmd,#ioSpiMask  wz   ' Check for SPI commands
1D58(0021) DB 00 54 5C |                 if_nz   jmp     #spiEntryPoint
1D5C(0022) C8 53 BC 50 |                         movs    :getAction,i2cCmd       ' Get command specific action
1D60(0023) 08 90 7F 62 |                         test    i2cCmd,#ioBootCmd  wz   '  bit sequence.  ioBootCmd is
1D64(0024) 01 52 D4 50 |                 if_nz   movs    :getAction,#ioReadCmd   '   treated as ioReadCmd here
1D68(0025) AD 53 FC 80 |                         add     :getAction,#ActionTbl
1D6C(0026) D1 9D BF A0 |                         mov     i2cDataSet,i2cDataSet1
1D70(0027) D2 9F BF A0 |                         mov     i2cClkLow,i2cClkLow1
1D74(0028) D3 A1 BF A0 |                         mov     i2cClkHigh,i2cClkHigh1
1D78(0029) 00 8C BF A0 | :getAction              mov     Action,0-0
1D7C(002A) 40 B8 7F 61 |                         test    Options,#ioLowSpeed wc  ' Set bus speed based on option
1D80(002B) D4 9D 8F A0 |                 if_nc   mov     i2cDataSet,i2cDataSet4
1D84(002C) D5 9F 8F A0 |                 if_nc   mov     i2cClkLow,i2cClkLow4
1D88(002D) D6 A1 8F A0 |                 if_nc   mov     i2cClkHigh,i2cClkHigh4
1D8C(002E) CD 95 BF A0 |                         mov     i2cTemp,i2cAddr
1D90(002F) 12 94 FF 28 |                         shr     i2cTemp,#18             ' Determine bit masks for
1D94(0030) 1E 94 FF 60 |                         and     i2cTemp,#%11110         '  I/O pins for I2C bus
1D98(0031) 01 BA FF A0 |                         mov     i2cSCL,#1
1D9C(0032) CA BB BF 2C |                         shl     i2cSCL,i2cTemp
1DA0(0033) DD BD BF A0 |                         mov     i2cSDA,i2cSCL           ' SDA is next higher pin
1DA4(0034) 01 BC FF 2C |                         shl     i2cSDA,#1
1DA8(0035) DD 93 3F 62 |                         test    FirstCall,i2cSCL   wz   ' Is this our first call?
1DAC(0036) DD 93 BF 64 |                         andn    FirstCall,i2cSCL        '  if so, do a reset
1DB0(0037) 73 02 D5 5C |                 if_nz   call    #i2cReset
1DB4(0038) 82 20 FD 5C |                         call    #i2cStart               ' Do a start sequence
1DB8(0039) 01 8C 7F 62 |                         test    Action,#%000000001 wz
1DBC(003A) 42 00 68 5C |                 if_z    jmp     #:skipAction0
1DC0(003B) CD C1 BF A0 |                         mov     i2cData,i2cAddr         ' Construct a device select
1DC4(003C) 0F C0 FF 28 |                         shr     i2cData,#15             '  code for EEPROM write mode
1DC8(003D) 0E C0 FF 60 |                         and     i2cData,#%00001110      '   with 2 address bytes
1DCC(003E) A0 C0 FF 68 |                         or      i2cData,#%10100000
1DD0(003F) 80 C2 FF A0 |                         mov     i2cMask,#%10000000
1DD4(0040) 9E 76 FD 5C |                         call    #i2cWrite               ' Send device select code
1DD8(0041) 70 00 70 5C |                 if_c    jmp     #:doStop                ' Failure if NAK received
1DDC(0042) 02 8C 7F 62 | :skipAction0            test    Action,#%000000010 wz
1DE0(0043) 49 00 68 5C |                 if_z    jmp     #:skipAction1
1DE4(0044) CD C1 BF A0 |                         mov     i2cData,i2cAddr         ' First address byte is most
1DE8(0045) 08 C0 FF 28 |                         shr     i2cData,#8              '  significant byte of address
1DEC(0046) 80 C2 FF A0 |                         mov     i2cMask,#%10000000
1DF0(0047) 9E 76 FD 5C |                         call    #i2cWrite               ' Send first address byte
1DF4(0048) 70 00 70 5C |                 if_c    jmp     #:doStop                ' Failure if NAK received
1DF8(0049) 04 8C 7F 62 | :skipAction1            test    Action,#%000000100 wz
1DFC(004A) 4F 00 68 5C |                 if_z    jmp     #:skipAction2
1E00(004B) CD C1 BF A0 |                         mov     i2cData,i2cAddr         ' Second address byte is least
1E04(004C) 80 C2 FF A0 |                         mov     i2cMask,#%10000000      '  significant byte of address
1E08(004D) 9E 76 FD 5C |                         call    #i2cWrite               ' Send second address byte
1E0C(004E) 70 00 70 5C |                 if_c    jmp     #:doStop                ' Failure if NAK received
1E10(004F) 70 96 7F EC | :skipAction2            tjz     i2cCount,#:doStop       ' If byte count == 0, we're done
1E14(0050) 08 8C 7F 62 |                         test    Action,#%000001000 wz
1E18(0051) 82 20 D5 5C |                 if_nz   call    #i2cStart               ' Do a start sequence if readdressing
1E1C(0052) 10 8C 7F 62 | :doReadWrite            test    Action,#%000010000 wz
1E20(0053) CC C1 97 00 |                 if_nz   rdbyte  i2cData,i2cBufAdr       ' If writing, fetch the data value
1E24(0054) 01 98 D7 80 |                 if_nz   add     i2cBufAdr,#1            '  and increment the hub address
1E28(0055) 20 8C 7F 62 |                         test    Action,#%000100000 wz
1E2C(0056) 5B 00 68 5C |                 if_z    jmp     #:skipAction5
1E30(0057) CD C1 BF A0 |                         mov     i2cData,i2cAddr         ' If reading, construct a device select
1E34(0058) 0F C0 FF 28 |                         shr     i2cData,#15             '  code for EEPROM read mode with
1E38(0059) 0E C0 FF 60 |                         and     i2cData,#%00001110      '   2 address bytes
1E3C(005A) A1 C0 FF 68 |                         or      i2cData,#%10100001
1E40(005B) 40 8C 7F 62 | :skipAction5            test    Action,#%001000000 wz
1E44(005C) 60 00 68 5C |                 if_z    jmp     #:skipAction6
1E48(005D) CD C1 BF A0 |                         mov     i2cData,i2cAddr         ' If reading using a single byte address
1E4C(005E) 08 C0 FF 28 |                         shr     i2cData,#8              '  construct a device select code for
1E50(005F) 01 C0 FF 68 |                         or      i2cData,#%00000001      '   read mode given one for write mode
1E54(0060) 80 8C 7F 62 | :skipAction6            test    Action,#%010000000 wz
1E58(0061) 65 00 68 5C |                 if_z    jmp     #:skipAction7
1E5C(0062) 80 C2 FF A0 |                         mov     i2cMask,#%10000000      ' Either readdress device for reading
1E60(0063) 9E 76 FD 5C |                         call    #i2cWrite               '  or write a data value at this point
1E64(0064) 70 00 70 5C |                 if_c    jmp     #:doStop                ' Failure if NAK received
1E68(0065) 00 8D 7F 62 | :skipAction7            test    Action,#%100000000 wz
1E6C(0066) 6E 00 68 5C |                 if_z    jmp     #:skipAction8
1E70(0067) 02 96 7F 85 |                         cmp     i2cCount,#2        wc   ' Carry true if this is the last byte
1E74(0068) 80 C2 FF A0 |                         mov     i2cMask,#%10000000
1E78(0069) 00 C0 FF A0 |                         mov     i2cData,#0
1E7C(006A) BC B4 FD 5C |                         call    #i2cRead
1E80(006B) 72 05 FF 5C |                         call    #StoreData              ' Now force carry false to show success
1E84(006C) 00 5A 7F 69 |                         or      i2cZero,#0      nr,wc
1E88(006D) E0 8C FF 64 |                         andn    Action,#%011100000      ' No readdressing on subsequent reads
1E8C(006E) 01 9A FF 80 | :skipAction8            add     i2cAddr,#1
1E90(006F) 52 96 FF E4 |                         djnz    i2cCount,#:doReadWrite  ' Repeat for number of bytes requested
1E94(0070) 91 3A FD 5C | :doStop                 call    #i2cStop
1E98(0071) B6 9B B3 68 |                 if_c    or      i2cAddr,errorFlag       ' Carry true indicates error
1E9C(0072) 1F 01 7C 5C |                         jmp     #checkEndIO
1EA0(0073) DE ED BF 64 | i2cReset                andn    dira,i2cSDA             ' Pullup drive SDA high
1EA4(0074) 09 C4 FF A0 |                         mov     i2cBitCnt,#9            ' Number of clock cycles
1EA8(0075) CF BF BF A0 |                         mov     i2cTime,i2cClkLow
1EAC(0076) F1 BF BF 80 |                         add     i2cTime,cnt             ' Allow for minimum SCL low
1EB0(0077) DD E9 BF 64 | :i2cResetClk            andn    outa,i2cSCL             ' Active drive SCL low
1EB4(0078) DD ED BF 68 |                         or      dira,i2cSCL            
1EB8(0079) D0 BF BF F8 |                         waitcnt i2cTime,i2cClkHigh
1EBC(007A) DD 75 3F 62 |                         test    i2cBootSCLm,i2cSCL wz   ' Check for boot I2C bus
1EC0(007B) DD E9 97 68 |               if_nz     or      outa,i2cSCL             ' Active drive SCL high
1EC4(007C) DD ED 97 68 |               if_nz     or      dira,i2cSCL
1EC8(007D) DD ED AB 64 |               if_z      andn    dira,i2cSCL             ' Pullup drive SCL high
1ECC(007E) CF BF BF F8 |                         waitcnt i2cTime,i2cClkLow       ' Allow minimum SCL high
1ED0(007F) F2 BD 3F 62 |                         test    i2cSDA,ina         wz   ' Stop if SDA is high
1ED4(0080) 77 C4 EB E4 |               if_z      djnz    i2cBitCnt,#:i2cResetClk ' Stop after 9 cycles
1ED8(0081) 00 00 7C 5C | i2cReset_ret            ret                             ' Should be ready for Start      
1EDC(0082) DE ED BF 64 | i2cStart                andn    dira,i2cSDA             ' Pullup drive SDA high
1EE0(0083) DE E9 BF 64 |                         andn    outa,i2cSDA             ' SDA set to drive low
1EE4(0084) CF BF BF A0 |                         mov     i2cTime,i2cClkLow
1EE8(0085) F1 BF BF 80 |                         add     i2cTime,cnt             ' Allow for bus free time
1EEC(0086) D0 BF BF F8 |                         waitcnt i2cTime,i2cClkHigh
1EF0(0087) DD 75 3F 62 |                         test    i2cBootSCLm,i2cSCL wz   ' Check for boot I2C bus
1EF4(0088) DD E9 97 68 |               if_nz     or      outa,i2cSCL             ' Active drive SCL high
1EF8(0089) DD ED 97 68 |               if_nz     or      dira,i2cSCL
1EFC(008A) DD ED AB 64 |               if_z      andn    dira,i2cSCL             ' Pullup drive SCL high
1F00(008B) D0 BF BF F8 |                         waitcnt i2cTime,i2cClkHigh      ' Allow for start setup time
1F04(008C) DE ED BF 68 |                         or      dira,i2cSDA             ' Active drive SDA low
1F08(008D) 00 BE FF F8 |                         waitcnt i2cTime,#0              ' Allow for start hold time
1F0C(008E) DD E9 BF 64 |                         andn    outa,i2cSCL             ' Active drive SCL low
1F10(008F) DD ED BF 68 |                         or      dira,i2cSCL
1F14(0090) 00 00 7C 5C | i2cStart_ret            ret                             
1F18(0091) DE ED BF 68 | i2cStop                 or      dira,i2cSDA             ' Active drive SDA low
1F1C(0092) CF BF BF A0 |                         mov     i2cTime,i2cClkLow
1F20(0093) F1 BF BF 80 |                         add     i2cTime,cnt             ' Wait for minimum clock low
1F24(0094) CF BF BF F8 |                         waitcnt i2cTime,i2cClkLow
1F28(0095) DD 75 3F 62 |                         test    i2cBootSCLm,i2cSCL wz   ' Check for boot I2C bus
1F2C(0096) DD E9 97 68 |               if_nz     or      outa,i2cSCL             ' Active drive SCL high
1F30(0097) DD ED 97 68 |               if_nz     or      dira,i2cSCL
1F34(0098) DD ED AB 64 |               if_z      andn    dira,i2cSCL             ' Pullup drive SCL high
1F38(0099) D0 BF BF F8 |                         waitcnt i2cTime,i2cClkHigh      ' Wait for minimum setup time
1F3C(009A) DE ED BF 64 |                         andn    dira,i2cSDA             ' Pullup drive SDA high
1F40(009B) 00 BE FF F8 |                         waitcnt i2cTime,#0              ' Allow for bus free time
1F44(009C) DD ED BF 64 |                         andn    dira,i2cSCL             ' Leave SCL and SDA high
1F48(009D) 00 00 7C 5C | i2cStop_ret             ret
1F4C(009E) 08 C4 FF A0 | i2cWrite                mov     i2cBitCnt,#8
1F50(009F) CF BF BF A0 |                         mov     i2cTime,i2cClkLow
1F54(00A0) F1 BF BF 80 |                         add     i2cTime,cnt             ' Wait for minimum SCL low
1F58(00A1) CE BF BF F8 | :i2cWriteBit            waitcnt i2cTime,i2cDataSet
1F5C(00A2) E1 C1 3F 62 |                         test    i2cData,i2cMask    wz
1F60(00A3) DE ED AB 68 |               if_z      or      dira,i2cSDA             ' Copy data bit to SDA
1F64(00A4) DE ED 97 64 |               if_nz     andn    dira,i2cSDA
1F68(00A5) D0 BF BF F8 |                         waitcnt i2cTime,i2cClkHigh      ' Wait for minimum setup time
1F6C(00A6) DD 75 3F 62 |                         test    i2cBootSCLm,i2cSCL wz   ' Check for boot I2C bus
1F70(00A7) DD E9 97 68 |               if_nz     or      outa,i2cSCL             ' Active drive SCL high
1F74(00A8) DD ED 97 68 |               if_nz     or      dira,i2cSCL
1F78(00A9) DD ED AB 64 |               if_z      andn    dira,i2cSCL             ' Pullup drive SCL high
1F7C(00AA) CF BF BF F8 |                         waitcnt i2cTime,i2cClkLow
1F80(00AB) DD E9 BF 64 |                         andn    outa,i2cSCL             ' Active drive SCL low
1F84(00AC) DD ED BF 68 |                         or      dira,i2cSCL
1F88(00AD) 01 C2 FF 20 |                         ror     i2cMask,#1              ' Go do next bit if not done
1F8C(00AE) A1 C4 FF E4 |                         djnz    i2cBitCnt,#:i2cWriteBit
1F90(00AF) DE ED BF 64 |                         andn    dira,i2cSDA             ' Switch SDA to input and
1F94(00B0) D0 BF BF F8 |                         waitcnt i2cTime,i2cClkHigh      '  wait for minimum SCL low
1F98(00B1) DD 75 3F 62 |                         test    i2cBootSCLm,i2cSCL wz   ' Check for boot I2C bus
1F9C(00B2) DD E9 97 68 |               if_nz     or      outa,i2cSCL             ' Active drive SCL high
1FA0(00B3) DD ED 97 68 |               if_nz     or      dira,i2cSCL
1FA4(00B4) DD ED AB 64 |               if_z      andn    dira,i2cSCL             ' Pullup drive SCL high
1FA8(00B5) 00 BE FF F8 |                         waitcnt i2cTime,#0              ' Wait for minimum high time
1FAC(00B6) F2 BD 3F 61 |                         test    i2cSDA,ina         wc   ' Sample SDA (ACK/NAK) then
1FB0(00B7) DD E9 BF 64 |                         andn    outa,i2cSCL             '  active drive SCL low
1FB4(00B8) DD ED BF 68 |                         or      dira,i2cSCL
1FB8(00B9) DE ED BF 68 |                         or      dira,i2cSDA             ' Leave SDA low
1FBC(00BA) 10 C2 FF 24 |                         rol     i2cMask,#16             ' Prepare for multibyte write
1FC0(00BB) 00 00 7C 5C | i2cWrite_ret            ret
1FC4(00BC) 08 C4 FF A0 | i2cRead                 mov     i2cBitCnt,#8
1FC8(00BD) DE ED BF 64 |                         andn    dira,i2cSDA             ' Make sure SDA is set to input
1FCC(00BE) CF BF BF A0 |                         mov     i2cTime,i2cClkLow
1FD0(00BF) F1 BF BF 80 |                         add     i2cTime,cnt             ' Wait for minimum SCL low
1FD4(00C0) D0 BF BF F8 | :i2cReadBit             waitcnt i2cTime,i2cClkHigh
1FD8(00C1) DD 75 3F 62 |                         test    i2cBootSCLm,i2cSCL wz   ' Check for boot I2C bus
1FDC(00C2) DD E9 97 68 |               if_nz     or      outa,i2cSCL             ' Active drive SCL high
1FE0(00C3) DD ED 97 68 |               if_nz     or      dira,i2cSCL
1FE4(00C4) DD ED AB 64 |               if_z      andn    dira,i2cSCL             ' Pullup drive SCL high
1FE8(00C5) CF BF BF F8 |                         waitcnt i2cTime,i2cClkLow       ' Wait for minimum clock high
1FEC(00C6) F2 BD 3F 62 |                         test    i2cSDA,ina         wz   ' Sample SDA for data bits
1FF0(00C7) DD E9 BF 64 |                         andn    outa,i2cSCL             ' Active drive SCL low
1FF4(00C8) DD ED BF 68 |                         or      dira,i2cSCL
1FF8(00C9) E1 C1 97 68 |               if_nz     or      i2cData,i2cMask         ' Accumulate data bits
1FFC(00CA) E1 C1 AB 64 |               if_z      andn    i2cData,i2cMask
2000(00CB) 01 C2 FF 20 |                         ror     i2cMask,#1              ' Shift the bit mask and
2004(00CC) C0 C4 FF E4 |                         djnz    i2cBitCnt,#:i2cReadBit  '  continue until done
2008(00CD) CE BF BF F8 |                         waitcnt i2cTime,i2cDataSet      ' Wait for end of SCL low
200C(00CE) DE ED B3 64 |               if_c      andn    dira,i2cSDA             ' Copy the ACK/NAK bit to SDA
2010(00CF) DE ED 8F 68 |               if_nc     or      dira,i2cSDA
2014(00D0) D0 BF BF F8 |                         waitcnt i2cTime,i2cClkHigh      ' Wait for minimum setup time
2018(00D1) DD 75 3F 62 |                         test    i2cBootSCLm,i2cSCL wz   ' Check for boot I2C bus
201C(00D2) DD E9 97 68 |               if_nz     or      outa,i2cSCL             ' Active drive SCL high
2020(00D3) DD ED 97 68 |               if_nz     or      dira,i2cSCL
2024(00D4) DD ED AB 64 |               if_z      andn    dira,i2cSCL             ' Pullup drive SCL high
2028(00D5) 00 BE FF F8 |                         waitcnt i2cTime,#0              ' Wait for minimum clock high
202C(00D6) DD E9 BF 64 |                         andn    outa,i2cSCL             ' Active drive SCL low
2030(00D7) DD ED BF 68 |                         or      dira,i2cSCL
2034(00D8) DE ED BF 68 |                         or      dira,i2cSDA             ' Leave SDA low
2038(00D9) 10 C2 FF 24 |                         rol     i2cMask,#16             ' Prepare for multibyte read
203C(00DA) 00 00 7C 5C | i2cRead_ret             ret
2040(00DB) 08 90 7F 61 | spiEntryPoint           test    i2cCmd,#ioBootCmd  wc   ' Check for boot
2044(00DC) 0F 01 70 5C |               if_c      jmp     #spiDoRead              ' (Treat like read)
2048(00DD) 11 90 7F 87 |                         cmp     i2cCmd,#ioSpiStop wc,wz
204C(00DE) E3 00 70 5C |               if_c      jmp     #spiDoInit              ' Decode operation
2050(00DF) 04 01 68 5C |               if_z      jmp     #spiDoStop
2054(00E0) 13 90 7F 85 |                         cmp     i2cCmd,#ioSpiWrite wc
2058(00E1) 0F 01 70 5C |               if_c      jmp     #spiDoRead
205C(00E2) 29 01 7C 5C |                         jmp     #spiDoWrite
2060(00E3) E6 D3 FD 54 | spiDoInit               movd    :moveIt,#spiMaskCS
2064(00E4) 04 B4 FF A0 |                         mov     spiBlkCnt,#4
2068(00E5) 01 C2 FF A0 | :makeMask               mov     i2cMask,#1
206C(00E6) CD 95 BF A0 |                         mov     i2cTemp,i2cAddr         ' Only use lower 5 bits of
2070(00E7) 1F 94 FF 60 |                         and     i2cTemp,#%11111         '  6 bit shift count field
2074(00E8) CA C3 BF 2C |                         shl     i2cMask,i2cTemp
2078(00E9) E1 01 BC A0 | :moveIt                 mov     0-0,i2cMask             ' Store the bit mask for the pin
207C(00EA) 01 B4 7F 86 |                         cmp     spiBlkCnt,#1       wz
2080(00EB) E1 E9 97 68 |               if_ne     or      outa,i2cMask            ' Make all pins high outputs
2084(00EC) E1 ED 97 68 |               if_ne     or      dira,i2cMask            '  except DO is an input since
2088(00ED) E1 ED AB 64 |               if_e      andn    dira,i2cMask            '   input/output is card relative
208C(00EE) BB D3 BD 84 |                         sub     :moveIt,incrDst
2090(00EF) 06 9A FF 20 |                         ror     i2cAddr,#6
2094(00F0) E5 B4 FF E4 |                         djnz    spiBlkCnt,#:makeMask
2098(00F1) 18 9A FF 24 |                         rol     i2cAddr,#24             ' Leave i2cAddr unchanged
209C(00F2) F1 BF BF A0 |                         mov     i2cTime,cnt             ' Set up a 1 second timeout
20A0(00F3) C0 B5 BF A0 |                         mov     spiBlkCnt,spiInitCnt
20A4(00F4) 69 E3 FE 5C | :initRead               call    #spiRecvByte            ' Output a stream of 32K clocks
20A8(00F5) F4 B4 FF E4 |                         djnz    spiBlkCnt,#:initRead    '  in case SD card left in some
20AC(00F6) 00 BA FF A0 |                         mov     spiOp,#0                '   undefined state
20B0(00F7) 00 BC FF A0 |                         mov     spiParm,#0
20B4(00F8) 44 BF FE 5C |                         call    #spiSendCmd             ' Send a reset command and deselect
20B8(00F9) E6 E9 BF 68 |                         or      outa,spiMaskCS          '  to get SD card into SPI mode
20BC(00FA) 37 BA FF A0 | :waitIdle               mov     spiOp,#55
20C0(00FB) 44 BF FE 5C |                         call    #spiSendCmd             ' APP_CMD (Application Specific)
20C4(00FC) 29 BA FF A0 |                         mov     spiOp,#41
20C8(00FD) 44 BF FE 5C |                         call    #spiSendCmd             ' SEND_OP_COND (Initialization)
20CC(00FE) E6 E9 BF 68 |                         or      outa,spiMaskCS
20D0(00FF) 01 C0 7F 86 |                         cmp     i2cData,#1         wz   ' Wait until response not In Idle
20D4(0100) FA 00 68 5C |               if_e      jmp     #:waitIdle
20D8(0101) A5 C1 7F EC |                         tjz     i2cData,#i2cGoUpdate    ' Initialization complete
20DC(0102) B6 9B BF 68 |                         or      i2cAddr,errorFlag
20E0(0103) A5 01 7C 5C |                         jmp     #i2cGoUpdate            ' Could not initialize the card
20E4(0104) E6 E9 BF 68 | spiDoStop               or      outa,spiMaskCS          ' CS=1
20E8(0105) E3 ED BF 64 |                         andn    dira,spiMaskDO          ' disable D0 as output (s/be input anyway)
20EC(0106) 69 E3 FE 5C |                         call    #spiRecvByte            ' Output a stream of clocks 
20F0(0107) E6 ED BF 64 |                         andn    dira,spiMaskCS          ' CS input
20F4(0108) 00 CC FF A0 |                         mov     spiMaskCS,#0            ' 
20F8(0109) 00 C6 FF A0 |                         mov     spiMaskDO,#0            ' D0 already input (above)
20FC(010A) E5 ED BF 64 |                         andn    dira,spiMaskDI          ' DI input
2100(010B) 00 CA FF A0 |                         mov     spiMaskDI,#0            '  
2104(010C) E4 ED BF 64 |                         andn    dira,spiMaskClk         ' CLK input
2108(010D) 00 C8 FF A0 |                         mov     spiMaskClk,#0
210C(010E) A5 01 7C 5C |                         jmp     #i2cGoUpdate
2110(010F) 11 BA FF A0 | spiDoRead               mov     spiOp,#17               ' READ_SINGLE_BLOCK
2114(0110) F1 BF BF A0 | :readRepeat             mov     i2cTime,cnt             ' Save start of timeout
2118(0111) CD BD BF A0 |                         mov     spiParm,i2cAddr
211C(0112) 44 BF FE 5C |                         call    #spiSendCmd             ' Read from specified block
2120(0113) 56 BF FE 5C |                         call    #spiResponse
2124(0114) BB B5 BF A0 |                         mov     spiBlkCnt,spiBlkSize    ' Transfer a block at a time
2128(0115) 69 E3 FE 5C | :getRead                call    #spiRecvByte
212C(0116) 19 97 7F EC |                         tjz     i2cCount,#:skipStore    ' Check for count exhausted
2130(0117) 72 05 FF 5C |                         call    #StoreData
2134(0118) 01 96 FF 84 |                         sub     i2cCount,#1
2138(0119) 15 B5 FF E4 | :skipStore              djnz    spiBlkCnt,#:getRead     ' Are we done with the block?
213C(011A) 69 E3 FE 5C |                         call    #spiRecvByte
2140(011B) 69 E3 FE 5C |                         call    #spiRecvByte            ' Yes, finish with 16 clocks
2144(011C) 01 9A FF 80 |                         add     i2cAddr,#1
2148(011D) E6 E9 BF 68 |                         or      outa,spiMaskCS          ' Increment address, deselect card
214C(011E) 10 97 7F E8 |                         tjnz    i2cCount,#:readRepeat   '  and check for more blocks to do
2150(011F) 08 90 7F 61 | checkEndIO              test    i2cCmd,#ioBootCmd  wc
2154(0120) A5 01 4C 5C |                  if_nc  jmp     #i2cGoUpdate            ' If not booting, we're done
2158(0121) B6 9B 3F 61 |                         test    i2cAddr,errorFlag  wc
215C(0122) FF B6 FF 62 |                         and     CheckSum,#$FF      wz   ' If booting, no errors can occur
2160(0123) 83 01 48 5C |            if_z_and_nc  jmp     #nowBootSpin            '  and checksum must be zero
2164(0124) B6 9B BF 68 |                         or      i2cAddr,errorFlag
2168(0125) BF B9 7F 61 |                         test    Options,#noStore   wc
216C(0126) A5 01 70 5C |                  if_c   jmp     #i2cGoUpdate            ' Return error status if noStore
2170(0127) 01 8E FF 0C | stopThisCOG             cogid   i2cCogId                ' If an unrecoverable error occurs,
2174(0128) 03 8E 7F 0C |                         cogstop i2cCogId                '  stop this cog
2178(0129) 18 BA FF A0 | spiDoWrite              mov     spiOp,#24               ' WRITE_BLOCK
217C(012A) F1 BF BF A0 |                         mov     i2cTime,cnt             ' Setup timeout
2180(012B) CD BD BF A0 |                         mov     spiParm,i2cAddr
2184(012C) 44 BF FE 5C |                         call    #spiSendCmd             ' Write to specified block
2188(012D) FE C0 FF A0 |                         mov     i2cData,#$FE            ' Ask to start data transfer
218C(012E) 60 D1 FE 5C |                         call    #spiSendByte
2190(012F) BB B5 BF A0 |                         mov     spiBlkCnt,spiBlkSize    ' Transfer a block at a time
2194(0130) 00 C0 FF A0 | :putWrite               mov     i2cData,#0              '  padding with zeroes if needed
2198(0131) 35 97 7F EC |                         tjz     i2cCount,#:padWrite     ' Check for count exhausted
219C(0132) CC C1 BF 00 |                         rdbyte  i2cData,i2cBufAdr       ' If not, get the next data byte
21A0(0133) 01 98 FF 80 |                         add     i2cBufAdr,#1
21A4(0134) 01 96 FF 84 |                         sub     i2cCount,#1
21A8(0135) 60 D1 FE 5C | :padWrite               call    #spiSendByte
21AC(0136) 30 B5 FF E4 |                         djnz    spiBlkCnt,#:putWrite    ' Are we done with the block?
21B0(0137) 69 E3 FE 5C |                         call    #spiRecvByte
21B4(0138) 69 E3 FE 5C |                         call    #spiRecvByte            ' Yes, finish with 16 clocks
21B8(0139) 56 BF FE 5C |                         call    #spiResponse
21BC(013A) 1F C0 FF 60 |                         and     i2cData,#$1F            ' Check the response status
21C0(013B) 05 C0 7F 86 |                         cmp     i2cData,#5         wz
21C4(013C) B6 9B 97 68 |               if_ne     or      i2cAddr,errorFlag       ' Must be Data Accepted
21C8(013D) A5 01 54 5C |               if_ne     jmp     #i2cGoUpdate
21CC(013E) 00 BA FE 50 |                         movs    spiWaitData,#0          ' Wait until not busy
21D0(013F) 57 BF FE 5C |                         call    #spiWaitBusy
21D4(0140) 01 9A FF 80 |                         add     i2cAddr,#1
21D8(0141) E6 E9 BF 68 |                         or      outa,spiMaskCS          ' Increment block address and go
21DC(0142) 29 97 7F E8 |                         tjnz    i2cCount,#spiDoWrite    '  to next if more data remains
21E0(0143) A5 01 7C 5C |                         jmp     #i2cGoUpdate
21E4(0144) E6 E9 BF 64 | spiSendCmd              andn    outa,spiMaskCS          ' Send command sequence.  Begin by
21E8(0145) 69 E3 FE 5C |                         call    #spiRecvByte            '  selecting card and clocking
21EC(0146) DD C1 BF A0 |                         mov     i2cData,spiOp
21F0(0147) 40 C0 FF 68 |                         or      i2cData,#$40            ' Send command byte (1st 2 bits %01)
21F4(0148) 60 D1 FE 5C |                         call    #spiSendByte
21F8(0149) DE C1 BF A0 |                         mov     i2cData,spiParm
21FC(014A) 0F C0 FF 28 |                         shr     i2cData,#15             ' Supplied address is sector number
2200(014B) 60 D1 FE 5C |                         call    #spiSendByte 
2204(014C) DE C1 BF A0 |                         mov     i2cData,spiParm         ' Send to SD card as byte address,
2208(014D) 07 C0 FF 28 |                         shr     i2cData,#7              '  in multiples of 512 bytes
220C(014E) 60 D1 FE 5C |                         call    #spiSendByte
2210(014F) DE C1 BF A0 |                         mov     i2cData,spiParm         ' Total length of this address is
2214(0150) 01 C0 FF 2C |                         shl     i2cData,#1              '  four bytes
2218(0151) 60 D1 FE 5C |                         call    #spiSendByte
221C(0152) 00 C0 FF A0 |                         mov     i2cData,#0
2220(0153) 60 D1 FE 5C |                         call    #spiSendByte
2224(0154) 95 C0 FF A0 |                         mov     i2cData,#$95            ' CRC code (for 1st command only)
2228(0155) 60 D1 FE 5C |                         call    #spiSendByte
222C(0156) FF BA FE 50 | spiResponse             movs    spiWaitData,#$FF        ' Wait for response from card
2230(0157) 69 E3 FE 5C | spiWaitBusy             call    #spiRecvByte
2234(0158) F1 95 BF A0 |                         mov     i2cTemp,cnt
2238(0159) DF 95 BF 84 |                         sub     i2cTemp,i2cTime         ' Check for expired timeout (1 sec)
223C(015A) D8 95 3F 85 |                         cmp     i2cTemp,SaveClkFreq wc
2240(015B) B6 9B 8F 68 |               if_nc     or      i2cAddr,errorFlag
2244(015C) A5 01 4C 5C |               if_nc     jmp     #i2cGoUpdate
2248(015D) 00 C0 7F 86 | spiWaitData             cmp     i2cData,#0-0       wz   ' Wait for some other response
224C(015E) 57 01 68 5C |               if_e      jmp     #spiWaitBusy            '  than that specified
2250(015F)             | spiSendCmd_ret
2250(015F)             | spiResponse_ret
2250(015F) 00 00 7C 5C | spiWaitBusy_ret         ret
2254(0160) 80 C2 FF A0 | spiSendByte             mov     i2cMask,#%10000000
2258(0161) E0 C3 3F 61 | :sendBit                test    i2cMask,i2cData    wc
225C(0162) E4 E9 BF 64 |                         andn    outa,spiMaskClk         ' Send data bytes MSB first
2260(0163) E5 E9 BF 70 |                         muxc    outa,spiMaskDI
2264(0164) E4 E9 BF 68 |                         or      outa,spiMaskClk
2268(0165) 01 C2 FF 28 |                         shr     i2cMask,#1              ' When mask shifted out, we're done
226C(0166) 61 C3 7F E8 |                         tjnz    i2cMask,#:sendBit
2270(0167) E5 E9 BF 68 |                         or      outa,spiMaskDI          ' Leave DI in idle (high) state
2274(0168) 00 00 7C 5C | spiSendByte_ret         ret
2278(0169) 80 C2 FF A0 | spiRecvByte             mov     i2cMask,#%10000000
227C(016A) E4 E9 BF 64 | :recvBit                andn    outa,spiMaskClk         ' Receive data bytes MSB first
2280(016B) E4 E9 BF 68 |                         or      outa,spiMaskClk         ' Copy DO to data bit
2284(016C) F2 C7 3F 61 |                         test    spiMaskDO,ina      wc     
2288(016D) E1 C1 BF 70 |                         muxc    i2cData,i2cMask
228C(016E) 01 C2 FF 28 |                         shr     i2cMask,#1              ' When mask shifted out, we're done
2290(016F) 6A C3 7F E8 |                         tjnz    i2cMask,#:recvBit
2294(0170) FF C0 FF 60 |                         and     i2cData,#%11111111      ' Eight bits received
2298(0171) 00 00 7C 5C | spiRecvByte_ret         ret
229C(0172) 20 B8 7F 61 | StoreData               test    Options,#ioNoStore wc
22A0(0173) CC C1 0F 00 |                 if_nc   wrbyte  i2cData,i2cBufAdr       ' Store data in specified location
22A4(0174) 01 98 FF 80 |                         add     i2cBufAdr,#1            '  and increment the address
22A8(0175) E0 B7 BF 80 |                         add     CheckSum,i2cData        ' Accumulate checksum for ioBootCmd
22AC(0176) 00 C0 FF 2C | ShiftData               shl     i2cData,#0-0
22B0(0177) E0 85 BF 68 | StoreLocal              or      Preamble+0,i2cData      ' Store a local copy of the program
22B4(0178) 08 EC FE 80 |                         add     ShiftData,#8            '  preamble for when we're reading
22B8(0179) BC ED 3E 86 |                         cmp     ShiftData,testIns  wz   '   in a new Spin program
22BC(017A) 00 EC EA 50 |                 if_z    movs    ShiftData,#0            ' Pack the data into successive longs
22C0(017B) BB EF AA 80 |                 if_z    add     StoreLocal,incrDst
22C4(017C) BE EF 2A 86 |                 if_z    cmp     StoreLocal,testDst wz   ' Stop after saving $0010 bytes
22C8(017D) BF EF AA A0 |                 if_z    mov     StoreLocal,noStore
22CC(017E) 08 90 6B 61 |                 if_z    test    i2cCmd,#ioBootCmd  wc   ' If we're reading in a new program,
22D0(017F) C4 97 A3 A0 |           if_c_and_z    mov     i2cCount,Preamble+2     '  change i2cCount to vbase adjusted
22D4(0180) B4 97 A3 60 |           if_c_and_z    and     i2cCount,i2cWordMask    '  by number of bytes loaded so far.
22D8(0181) 0F 96 E3 84 |           if_c_and_z    sub     i2cCount,#16 - 1        ' i2cCount will be decremented again
22DC(0182) 00 00 7C 5C | StoreData_ret           ret
22E0(0183) 20 B8 7F 61 | nowBootSpin             test    Options,#ioNoStore wc
22E4(0184) C4 95 BF A0 |                         mov     i2cTemp,Preamble+2
22E8(0185) 10 94 FF 28 |                         shr     i2cTemp,#16             ' Get dbase value
22EC(0186) 04 94 FF 84 |                         sub     i2cTemp,#4
22F0(0187) CA 83 0F 08 |                 if_nc   wrlong  StackMark,i2cTemp       ' Place stack marker at dbase
22F4(0188) 04 94 FF 84 |                         sub     i2cTemp,#4
22F8(0189) CA 83 0F 08 |                 if_nc   wrlong  StackMark,i2cTemp
22FC(018A) C4 8F BF A0 |                         mov     i2cOther,Preamble+2     ' Get vbase value
2300(018B) B4 8F BF 60 |                         and     i2cOther,i2cWordMask
2304(018C) C7 95 BF 84 |                         sub     i2cTemp,i2cOther
2308(018D) 02 94 FF 2A |                         shr     i2cTemp,#2         wz   ' Compute number of longs between
230C(018E) C7 5B 07 08 | :zeroIt  if_nz_and_nc   wrlong  i2cZero,i2cOther        '  vbase and below stack marker
2310(018F) 04 8E C7 80 |          if_nz_and_nc   add     i2cOther,#4
2314(0190) 8E 95 C7 E4 |          if_nz_and_nc   djnz    i2cTemp,#:zeroIt        ' Zero that space (if any)
2318(0191) C2 95 BF A0 |                         mov     i2cTemp,Preamble
231C(0192) D8 95 3F 86 |                         cmp     i2cTemp,SaveClkFreq wz  ' Is the clock frequency the same?
2320(0193) C3 95 BF A0 |                         mov     i2cTemp,Preamble+1
2324(0194) FF 94 FF 60 |                         and     i2cTemp,#$FF            ' Is the clock mode the same also?
2328(0195) 98 01 54 5C |                 if_ne   jmp     #:changeClock
232C(0196) D9 95 3F 86 |                         cmp     i2cTemp,SaveClkMode wz  ' If both same, just go start COG
2330(0197) 9F 01 68 5C |                 if_e    jmp     #:justStartUp
2334(0198) F8 94 FF 60 | :changeClock            and     i2cTemp,#$F8            ' Force use of RCFAST clock while
2338(0199) 00 94 4F 0C |                 if_nc   clkset  i2cTemp                 '  letting requested clock start
233C(019A) B8 95 BF A0 |                         mov     i2cTemp,time_xtal
2340(019B) 9B 95 FF E4 | :startupDelay           djnz    i2cTemp,#:startupDelay  ' Allow 20ms@20MHz for xtal/pll to settle
2344(019C) C3 95 BF A0 |                         mov     i2cTemp,Preamble+1
2348(019D) FF 94 FF 60 |                         and     i2cTemp,#$FF            ' Then switch to selected clock
234C(019E) 00 94 4F 0C |                 if_nc   clkset  i2cTemp
2350(019F) C8 8F BF A0 | :justStartUp            mov     i2cOther,i2cCmd         ' Use the COG supplied as the caller's
2354(01A0) 07 8E FF 60 |                         and     i2cOther,#%111          '  to start up the SPIN interpreter
2358(01A1) 80 B8 7F 62 |                         test    Options,#ioStopLdr  wz  ' If ioStopLdr is set and ioNoStore is
235C(01A2) 01 8E D7 0C |                 if_nz   cogid   i2cOther                '  clear, then use this cog for SPIN
2360(01A3) B9 8F BF 68 |                         or      i2cOther,interpreter
2364(01A4) 02 8E 4F 0C |                 if_nc   coginit i2cOther
2368(01A5) B4 99 BF 60 | i2cGoUpdate             and     i2cBufAdr,i2cWordMask   ' Copy updated information
236C(01A6) 10 96 FF 2C |                         shl     i2cCount,#16            '  back to control packet
2370(01A7) CC 97 BF 68 |                         or      i2cCount,i2cBufAdr
2374(01A8) F0 95 BF A0 |                         mov     i2cTemp,PAR
2378(01A9) 04 94 FF 80 |                         add     i2cTemp,#4
237C(01AA) CA 97 3F 08 |                         wrlong  i2cCount,i2cTemp
2380(01AB) F0 9B 3F 08 |                         wrlong  i2cAddr,PAR             ' Indicate operation is done
2384(01AC) 00 00 7C 5C |                         jmp     #i2cEntryPoint          '  and go wait for a new one
2388(01AD)             | i2cZero
2388(01AD) 00 00 00 00 | ActionTbl               long    %0000000000             ' Command not used (indicates done)
238C(01AE) AF 01 00 00 |                         long    %0110101111,%0010010111 ' Read/Write with 2 bytes of addressing
2390(01AF) 97 00 00 00 | 
2394(01B0) CE 01 00 00 |                         long    %0111001110,%0010010110 ' Read/Write with 1 byte of addressing
2398(01B1) 96 00 00 00 | 
239C(01B2) 04 01 00 00 |                         long    %0100000100,%0010010100 ' Read/Write data only
23A0(01B3) 94 00 00 00 | 
23A4(01B4) FF FF 00 00 | i2cWordMask             long    $0000FFFF
23A8(01B5) FF FF FF 00 | i2cAddrMask             long    $00FFFFFF
23AC(01B6) 00 00 00 80 | errorFlag               long    $80000000               ' NAK received during write cycle
23B0(01B7) 00 00 00 40 | speedMask               long    $40000000               ' One if 100KHz bus, zero if 400KHz
23B4(01B8) A0 86 01 00 | time_xtal               long    20 * 20000 / 4 / 1      ' 20ms (@20MHz, 1 inst/loop)
23B8(01B9) 10 C0 07 00 | interpreter             long    ($0004 << 16) | ($F004 << 2) | %0000
23BC(01BA) 00 00 00 10 | i2cBootSCLm             long    |<i2cBootSCL            ' Bit mask for pin 28 SCL use
23C0(01BB)             | spiBlkSize                                              ' Number of bytes in an SD card block
23C0(01BB) 00 02 00 00 | incrDst                 long    %10_00000000            ' Used to increment destination field
23C4(01BC) 20 C0 FF 2C | testIns                 shl     i2cData,#32             ' Used to compare for end of word packing
23C8(01BD) E0 85 BF 68 | initStore               or      Preamble+0,i2cData      ' Used to initialize packing instruction
23CC(01BE) E0 8D BF 68 | testDst                 or      Preamble+4,i2cData      ' Used to check for end of packing buffer
23D0(01BF) 82 01 7C 5C | noStore                 jmp     #StoreData_ret          ' Used after all data stored into Preamble
23D4(01C0) 00 10 00 00 | spiInitCnt              long    32768 / 8               ' Initial SPI clocks produced
23D8(01C1) FF FF F9 FF | StackMark               long    $FFF9FFFF               ' Two of these mark the base of the stack
23DC(01C2) 00 00 00 00 | Preamble                long    0, 0, 0, 0              ' Private copy of program preamble
23E0(01C3) 00 00 00 00 | 
23E4(01C4) 00 00 00 00 | 
23E8(01C5) 00 00 00 00 | 
23EC(01C6) 00 00 00 00 | Action                  long    0
23F0(01C7)             | i2cOther
23F0(01C7) 00 00 00 00 | i2cCogId                long    0
23F4(01C8) 00 00 00 00 | i2cCmd                  long    0
23F8(01C9) FF FF FF FF | FirstCall               long    -1                      ' One if I2C pins not initialized yet
23FC(01CA) 00 00 00 00 | i2cTemp                 long    0
2400(01CB) 00 00 00 00 | i2cCount                long    0
2404(01CC) 00 00 00 00 | i2cBufAdr               long    0
2408(01CD) 00 00 00 00 | i2cAddr                 long    0
240C(01CE) 00 00 00 00 | i2cDataSet              long    0                       ' Minumum data setup time (ticks)
2410(01CF) 00 00 00 00 | i2cClkLow               long    0                       ' Minimum clock low time (ticks)
2414(01D0) 00 00 00 00 | i2cClkHigh              long    0                       ' Minimum clock high time (ticks)
2418(01D1) 00 00 00 00 | i2cDataSet1             long    0                       ' Minumum data setup time (ticks) 100KHz
241C(01D2) 00 00 00 00 | i2cClkLow1              long    0                       ' Minimum clock low time (ticks) 100KHz
2420(01D3) 00 00 00 00 | i2cClkHigh1             long    0                       ' Minimum clock high time (ticks) 100KHz
2424(01D4) 00 00 00 00 | i2cDataSet4             long    0                       ' Minumum data setup time (ticks) 400KHz
2428(01D5) 00 00 00 00 | i2cClkLow4              long    0                       ' Minimum clock low time (ticks) 400KHz
242C(01D6) 00 00 00 00 | i2cClkHigh4             long    0                       ' Minimum clock high time (ticks) 400KHz
2430(01D7) 00 00 00 00 | i2cPause                long    0                       ' Pause before re-fetching next operation
2434(01D8) 00 00 00 00 | SaveClkFreq             long    0                       ' Initial clock frequency (clkfreqVal)
2438(01D9) 00 00 00 00 | SaveClkMode             long    0                       ' Initial clock mode value (clksetVal)
243C(01DA) 00 00 00 00 | spiBlkCnt               long    0                       ' Number of SD card bytes to go in block
2440(01DB) 00 00 00 00 | CheckSum                long    0                       ' Checksum of bytes for ioBootCmd
2444(01DC) 00 00 00 00 | Options                 long    0                       ' Option bits (ioNoStore, ioLowSpeed)
2448(01DD)             | spiOp                                                   ' Operation code for SPI command
2448(01DD) 00 00 00 00 | i2cSCL                  long    0                       ' Bit mask for SCL
244C(01DE)             | spiParm                                                 ' Parameter value for SPI command
244C(01DE) 00 00 00 00 | i2cSDA                  long    0                       ' Bit mask for SDA
2450(01DF) 00 00 00 00 | i2cTime                 long    0                       ' Used for timekeeping
2454(01E0) 00 00 00 00 | i2cData                 long    0                       ' Data to be transmitted / received
2458(01E1) 00 00 00 00 | i2cMask                 long    0                       ' Bit mask for bit to be tx / rx
245C(01E2) 00 00 00 00 | i2cBitCnt               long    0                       ' Number of bits to tx / rx
2460(01E3) 00 00 00 00 | spiMaskDO               long    0
2464(01E4) 00 00 00 00 | spiMaskClk              long    0
2468(01E5) 00 00 00 00 | spiMaskDI               long    0
246C(01E6) 00 00 00 00 | spiMaskCS               long    0
2470(01E7)             |                         fit     $1F0
2470(01E7)             | There are 9 ($009) Longs left in the cog
|===========================================================================|
|===========================================================================|
Spin Block checkPresence with 1 Parameters and 1 Extra Stack Longs. Method 1
PUB checkPresence(addr) | t

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - addr
Local Variable  DBASE:0008 - t
|===========================================================================|
145                        t := ioReadCmd | ioLowSpeed
Addr : 2470:             36  : Constant 2 $00000001
Addr : 2471:          37 05  : Constant Mask Y=5 00000040 64
Addr : 2473:             EA  : Math Op |     
Addr : 2474:             69  : Variable Operation Local Offset - 2 Write
Addr : 2475: Label0002
146                        repeat while long[control][0] & ioTestRdy            ' Wait for previous I/O to finish
Addr : 2475:             44  : Variable Operation Global Offset - 1 Read
Addr : 2476:             35  : Constant 1 $00000000
Addr : 2477:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2478: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 247D:             E8  : Math Op &     
Addr : 247E: JZ Label0004
Addr : 247E:          0A 02  : jz Address = 2482 2
Addr : 2480: Label0003
Addr : 2480: JMP Label0002
Addr : 2480:          04 73  : Jmp 2475 -13  
Addr : 2482: Label0004
147                        long[control][1] := 0                                ' Attempt to address the device
Addr : 2482:             35  : Constant 1 $00000000
Addr : 2483:             44  : Variable Operation Global Offset - 1 Read
Addr : 2484:             36  : Constant 2 $00000001
Addr : 2485:             D1  : Memory Op Long POP Address POP Index WRITE 
148                        long[control][0] := (t << 24) | (addr & $FFFFFF)
Addr : 2486:             68  : Variable Operation Local Offset - 2 Read
Addr : 2487:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 2489:             E3  : Math Op <<    
Addr : 248A:             64  : Variable Operation Local Offset - 1 Read
Addr : 248B:          37 37  : Constant Mask Y=55 Decrement 00FFFFFF 16777215
Addr : 248D:             E8  : Math Op &     
Addr : 248E:             EA  : Math Op |     
Addr : 248F:             44  : Variable Operation Global Offset - 1 Read
Addr : 2490:             35  : Constant 1 $00000000
Addr : 2491:             D1  : Memory Op Long POP Address POP Index WRITE 
Addr : 2492: Label0005
149                        repeat while long[control][0] & ioTestRdy            ' Wait for this to finish
Addr : 2492:             44  : Variable Operation Global Offset - 1 Read
Addr : 2493:             35  : Constant 1 $00000000
Addr : 2494:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2495: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 249A:             E8  : Math Op &     
Addr : 249B: JZ Label0007
Addr : 249B:          0A 02  : jz Address = 249F 2
Addr : 249D: Label0006
Addr : 249D: JMP Label0005
Addr : 249D:          04 73  : Jmp 2492 -13  
Addr : 249F: Label0007
150                        return (long[control][0] & ioTestErr) == 0           ' Return false on error
Addr : 249F:             44  : Variable Operation Global Offset - 1 Read
Addr : 24A0:             35  : Constant 1 $00000000
Addr : 24A1:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 24A2:          37 1E  : Constant Mask Y=30 80000000 2147483648
Addr : 24A4:             E8  : Math Op &     
Addr : 24A5:             35  : Constant 1 $00000000
Addr : 24A6:             FC  : Math Op ==    
Addr : 24A7:             33  : Return value  
Addr : 24A8: Data : 32                       2
|===========================================================================|
Spin Block writeWait with 1 Parameters and 1 Extra Stack Longs. Method 2
PUB writeWait(addr) | t                                '' Wait for EEPROM to complete write

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - addr
Local Variable  DBASE:0008 - t
|===========================================================================|
153                        t := cnt
Addr : 24A9:          3F 91  : Register op CNT Read
Addr : 24AB:             69  : Variable Operation Local Offset - 2 Write
Addr : 24AC: Label0002
154                        repeat until checkPresence(addr)                     ' Maximum wait time is 20ms
Addr : 24AC:             00  : Drop Anchor Push 
Addr : 24AD:             64  : Variable Operation Local Offset - 1 Read
Addr : 24AE:          05 01  : Call Sub 1    
Addr : 24B0: JNZ Label0004
Addr : 24B0:          0B 10  : jnz Address = 24C2 16
155                          if (cnt - t) > (clkfreq / 50)
Addr : 24B2:          3F 91  : Register op CNT Read
Addr : 24B4:             68  : Variable Operation Local Offset - 2 Read
Addr : 24B5:             ED  : Math Op -     
Addr : 24B6:             35  : Constant 1 $00000000
Addr : 24B7:             C0  : Memory Op Long POP Address READ 
Addr : 24B8:          38 32  : Constant 1 Bytes - 32 - $00000032 50
Addr : 24BA:             F6  : Math Op /     
Addr : 24BB:             FA  : Math Op >     
Addr : 24BC: JZ Label0005
Addr : 24BC:          0A 02  : jz Address = 24C0 2
156                            return true                                      ' Return true if a timeout occurred
Addr : 24BE:             34  : Constant 0 $FFFFFFFF
Addr : 24BF:             33  : Return value  
Addr : 24C0: Label0005
Addr : 24C0: Label0006
Addr : 24C0: Label0003
Addr : 24C0: JMP Label0002
Addr : 24C0:          04 6A  : Jmp 24AC -22  
Addr : 24C2: Label0004
157                        return false                                         ' Otherwise return false
Addr : 24C2:             35  : Constant 1 $00000000
Addr : 24C3:             33  : Return value  
Addr : 24C4: Data : 32                       2
|===========================================================================|
Spin Block computeTimes with 0 Parameters and 0 Extra Stack Longs. Method 3
PUB computeTimes                                       '' Set up timing constants in assembly

Local Parameter DBASE:0000 - Result
|===========================================================================|
161                        i2cDataSet1 := ((clkfreq / 10000) *  600) / 100000   ' Data setup time -  600ns (100KHz)
Addr : 24C5:             35  : Constant 1 $00000000
Addr : 24C6:             C0  : Memory Op Long POP Address READ 
Addr : 24C7:       39 27 10  : Constant 2 Bytes - 27 10 - $00002710 10000
Addr : 24CA:             F6  : Math Op /     
Addr : 24CB:       39 02 58  : Constant 2 Bytes - 02 58 - $00000258 600
Addr : 24CE:             F4  : Math Op *     
Addr : 24CF:    3A 01 86 A0  : Constant 3 Bytes - 01 86 A0 - $000186A0 100000
Addr : 24D3:             F6  : Math Op /     
Addr : 24D4:       C5 87 78  : Memory Op Long PBASE + WRITE Address = 0778
162                        i2cClkLow1  := ((clkfreq / 10000) * 4700) / 100000   ' Clock low time  - 4700ns (100KHz)
Addr : 24D7:             35  : Constant 1 $00000000
Addr : 24D8:             C0  : Memory Op Long POP Address READ 
Addr : 24D9:       39 27 10  : Constant 2 Bytes - 27 10 - $00002710 10000
Addr : 24DC:             F6  : Math Op /     
Addr : 24DD:       39 12 5C  : Constant 2 Bytes - 12 5C - $0000125C 4700
Addr : 24E0:             F4  : Math Op *     
Addr : 24E1:    3A 01 86 A0  : Constant 3 Bytes - 01 86 A0 - $000186A0 100000
Addr : 24E5:             F6  : Math Op /     
Addr : 24E6:       C5 87 7C  : Memory Op Long PBASE + WRITE Address = 077C
163                        i2cClkHigh1 := ((clkfreq / 10000) * 4000) / 100000   ' Clock high time - 4000ns (100KHz)
Addr : 24E9:             35  : Constant 1 $00000000
Addr : 24EA:             C0  : Memory Op Long POP Address READ 
Addr : 24EB:       39 27 10  : Constant 2 Bytes - 27 10 - $00002710 10000
Addr : 24EE:             F6  : Math Op /     
Addr : 24EF:       39 0F A0  : Constant 2 Bytes - 0F A0 - $00000FA0 4000
Addr : 24F2:             F4  : Math Op *     
Addr : 24F3:    3A 01 86 A0  : Constant 3 Bytes - 01 86 A0 - $000186A0 100000
Addr : 24F7:             F6  : Math Op /     
Addr : 24F8:       C5 87 80  : Memory Op Long PBASE + WRITE Address = 0780
164                        i2cDataSet4 := ((clkfreq / 10000) *  250) / 100000   ' Data setup time -  250ns (400KHz)
Addr : 24FB:             35  : Constant 1 $00000000
Addr : 24FC:             C0  : Memory Op Long POP Address READ 
Addr : 24FD:       39 27 10  : Constant 2 Bytes - 27 10 - $00002710 10000
Addr : 2500:             F6  : Math Op /     
Addr : 2501:          38 FA  : Constant 1 Bytes - FA - $000000FA 250
Addr : 2503:             F4  : Math Op *     
Addr : 2504:    3A 01 86 A0  : Constant 3 Bytes - 01 86 A0 - $000186A0 100000
Addr : 2508:             F6  : Math Op /     
Addr : 2509:       C5 87 84  : Memory Op Long PBASE + WRITE Address = 0784
165                        i2cClkLow4  := ((clkfreq / 10000) * 1300) / 100000   ' Clock low time  - 1300ns (400KHz)
Addr : 250C:             35  : Constant 1 $00000000
Addr : 250D:             C0  : Memory Op Long POP Address READ 
Addr : 250E:       39 27 10  : Constant 2 Bytes - 27 10 - $00002710 10000
Addr : 2511:             F6  : Math Op /     
Addr : 2512:       39 05 14  : Constant 2 Bytes - 05 14 - $00000514 1300
Addr : 2515:             F4  : Math Op *     
Addr : 2516:    3A 01 86 A0  : Constant 3 Bytes - 01 86 A0 - $000186A0 100000
Addr : 251A:             F6  : Math Op /     
Addr : 251B:       C5 87 88  : Memory Op Long PBASE + WRITE Address = 0788
166                        i2cClkHigh4 := ((clkfreq / 10000) * 1000) / 100000   ' Clock high time - 1000ns (400KHz)
Addr : 251E:             35  : Constant 1 $00000000
Addr : 251F:             C0  : Memory Op Long POP Address READ 
Addr : 2520:       39 27 10  : Constant 2 Bytes - 27 10 - $00002710 10000
Addr : 2523:             F6  : Math Op /     
Addr : 2524:       39 03 E8  : Constant 2 Bytes - 03 E8 - $000003E8 1000
Addr : 2527:             F4  : Math Op *     
Addr : 2528:    3A 01 86 A0  : Constant 3 Bytes - 01 86 A0 - $000186A0 100000
Addr : 252C:             F6  : Math Op /     
Addr : 252D:       C5 87 8C  : Memory Op Long PBASE + WRITE Address = 078C
167                        i2cPause    := clkfreq / 100000                      ' Pause between checks for operations
Addr : 2530:             35  : Constant 1 $00000000
Addr : 2531:             C0  : Memory Op Long POP Address READ 
Addr : 2532:    3A 01 86 A0  : Constant 3 Bytes - 01 86 A0 - $000186A0 100000
Addr : 2536:             F6  : Math Op /     
Addr : 2537:       C5 87 90  : Memory Op Long PBASE + WRITE Address = 0790
Addr : 253A:             32  : Return        
|===========================================================================|
Spin Block initSDCard with 4 Parameters and 1 Extra Stack Longs. Method 4
PUB initSDCard(DO,Clk,DI,CS) | t                       '' Initialize SD card access

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - DO
Local Parameter DBASE:0008 - Clk
Local Parameter DBASE:000C - DI
Local Parameter DBASE:0010 - CS
Local Variable  DBASE:0014 - t
|===========================================================================|
170                        t := cnt
Addr : 253B:          3F 91  : Register op CNT Read
Addr : 253D:             75  : Variable Operation Local Offset - 5 Write
Addr : 253E: Label0002
171                        repeat while long[control][0] & ioTestRdy            ' Wait for previous I/O to finish
Addr : 253E:             44  : Variable Operation Global Offset - 1 Read
Addr : 253F:             35  : Constant 1 $00000000
Addr : 2540:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2541: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 2546:             E8  : Math Op &     
Addr : 2547: JZ Label0004
Addr : 2547:          0A 02  : jz Address = 254B 2
Addr : 2549: Label0003
Addr : 2549: JMP Label0002
Addr : 2549:          04 73  : Jmp 253E -13  
Addr : 254B: Label0004
172                        long[control][1] := 0
Addr : 254B:             35  : Constant 1 $00000000
Addr : 254C:             44  : Variable Operation Global Offset - 1 Read
Addr : 254D:             36  : Constant 2 $00000001
Addr : 254E:             D1  : Memory Op Long POP Address POP Index WRITE 
173                        long[control][0] := ioSpiInit << 24 | DO << 18 | Clk << 12 | DI << 6 | CS
Addr : 254F:          37 03  : Constant Mask Y=3 00000010 16
Addr : 2551:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 2553:             E3  : Math Op <<    
Addr : 2554:             64  : Variable Operation Local Offset - 1 Read
Addr : 2555:          38 12  : Constant 1 Bytes - 12 - $00000012 18
Addr : 2557:             E3  : Math Op <<    
Addr : 2558:             EA  : Math Op |     
Addr : 2559:             68  : Variable Operation Local Offset - 2 Read
Addr : 255A:          38 0C  : Constant 1 Bytes - 0C - $0000000C 12
Addr : 255C:             E3  : Math Op <<    
Addr : 255D:             EA  : Math Op |     
Addr : 255E:             6C  : Variable Operation Local Offset - 3 Read
Addr : 255F:          38 06  : Constant 1 Bytes - 06 - $00000006 6
Addr : 2561:             E3  : Math Op <<    
Addr : 2562:             EA  : Math Op |     
Addr : 2563:             70  : Variable Operation Local Offset - 4 Read
Addr : 2564:             EA  : Math Op |     
Addr : 2565:             44  : Variable Operation Global Offset - 1 Read
Addr : 2566:             35  : Constant 1 $00000000
Addr : 2567:             D1  : Memory Op Long POP Address POP Index WRITE 
Addr : 2568: Label0005
174                        repeat while long[control][0] & ioTestRdy            ' Wait for this to finish
Addr : 2568:             44  : Variable Operation Global Offset - 1 Read
Addr : 2569:             35  : Constant 1 $00000000
Addr : 256A:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 256B: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 2570:             E8  : Math Op &     
Addr : 2571: JZ Label0007
Addr : 2571:          0A 02  : jz Address = 2575 2
Addr : 2573: Label0006
Addr : 2573: JMP Label0005
Addr : 2573:          04 73  : Jmp 2568 -13  
Addr : 2575: Label0007
175                        return (long[control][0] & ioTestErr) <> 0           ' Return any error code
Addr : 2575:             44  : Variable Operation Global Offset - 1 Read
Addr : 2576:             35  : Constant 1 $00000000
Addr : 2577:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2578:          37 1E  : Constant Mask Y=30 80000000 2147483648
Addr : 257A:             E8  : Math Op &     
Addr : 257B:             35  : Constant 1 $00000000
Addr : 257C:             FB  : Math Op <>    
Addr : 257D:             33  : Return value  
Addr : 257E: Data : 32                       2
|===========================================================================|
Spin Block stopSDCard with 0 Parameters and 0 Extra Stack Longs. Method 5
PUB stopSDCard                                         '' Stop SD card access

Local Parameter DBASE:0000 - Result
|===========================================================================|
178                        repeat while long[control][0] & ioTestRdy            ' Wait for previous I/O to finish
Addr : 257F: Label0002
Addr : 257F:             44  : Variable Operation Global Offset - 1 Read
Addr : 2580:             35  : Constant 1 $00000000
Addr : 2581:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2582: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 2587:             E8  : Math Op &     
Addr : 2588: JZ Label0004
Addr : 2588:          0A 02  : jz Address = 258C 2
Addr : 258A: Label0003
Addr : 258A: JMP Label0002
Addr : 258A:          04 73  : Jmp 257F -13  
Addr : 258C: Label0004
179                        long[control][1] := 0
Addr : 258C:             35  : Constant 1 $00000000
Addr : 258D:             44  : Variable Operation Global Offset - 1 Read
Addr : 258E:             36  : Constant 2 $00000001
Addr : 258F:             D1  : Memory Op Long POP Address POP Index WRITE 
180                        long[control][0] := ioSpiStop << 24
Addr : 2590:          38 11  : Constant 1 Bytes - 11 - $00000011 17
Addr : 2592:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 2594:             E3  : Math Op <<    
Addr : 2595:             44  : Variable Operation Global Offset - 1 Read
Addr : 2596:             35  : Constant 1 $00000000
Addr : 2597:             D1  : Memory Op Long POP Address POP Index WRITE 
Addr : 2598: Label0005
181                        repeat while long[control][0] & ioTestRdy            ' Wait for this to finish
Addr : 2598:             44  : Variable Operation Global Offset - 1 Read
Addr : 2599:             35  : Constant 1 $00000000
Addr : 259A:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 259B: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 25A0:             E8  : Math Op &     
Addr : 25A1: JZ Label0007
Addr : 25A1:          0A 02  : jz Address = 25A5 2
Addr : 25A3: Label0006
Addr : 25A3: JMP Label0005
Addr : 25A3:          04 73  : Jmp 2598 -13  
Addr : 25A5: Label0007
182                        return (long[control][0] & ioTestErr) <> 0           ' Return any error code
Addr : 25A5:             44  : Variable Operation Global Offset - 1 Read
Addr : 25A6:             35  : Constant 1 $00000000
Addr : 25A7:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 25A8:          37 1E  : Constant Mask Y=30 80000000 2147483648
Addr : 25AA:             E8  : Math Op &     
Addr : 25AB:             35  : Constant 1 $00000000
Addr : 25AC:             FB  : Math Op <>    
Addr : 25AD:             33  : Return value  
Addr : 25AE: Data : 32                       2
|===========================================================================|
Spin Block readSDCard with 3 Parameters and 0 Extra Stack Longs. Method 6
PUB readSDCard(addr,buffer,count)                      '' Read block(s) from SD card to RAM

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - addr
Local Parameter DBASE:0008 - buffer
Local Parameter DBASE:000C - count
|===========================================================================|
185                        repeat while long[control][0] & ioTestRdy            ' Wait for previous I/O to finish
Addr : 25AF: Label0002
Addr : 25AF:             44  : Variable Operation Global Offset - 1 Read
Addr : 25B0:             35  : Constant 1 $00000000
Addr : 25B1:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 25B2: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 25B7:             E8  : Math Op &     
Addr : 25B8: JZ Label0004
Addr : 25B8:          0A 02  : jz Address = 25BC 2
Addr : 25BA: Label0003
Addr : 25BA: JMP Label0002
Addr : 25BA:          04 73  : Jmp 25AF -13  
Addr : 25BC: Label0004
186                        long[control][1] := (count << 16) | (buffer & $FFFF)
Addr : 25BC:             6C  : Variable Operation Local Offset - 3 Read
Addr : 25BD:          37 03  : Constant Mask Y=3 00000010 16
Addr : 25BF:             E3  : Math Op <<    
Addr : 25C0:             68  : Variable Operation Local Offset - 2 Read
Addr : 25C1:          37 2F  : Constant Mask Y=47 Decrement 0000FFFF 65535
Addr : 25C3:             E8  : Math Op &     
Addr : 25C4:             EA  : Math Op |     
Addr : 25C5:             44  : Variable Operation Global Offset - 1 Read
Addr : 25C6:             36  : Constant 2 $00000001
Addr : 25C7:             D1  : Memory Op Long POP Address POP Index WRITE 
187                        long[control][0] := (ioSpiRead << 24) | (addr & $FFFFFF)
Addr : 25C8:          38 12  : Constant 1 Bytes - 12 - $00000012 18
Addr : 25CA:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 25CC:             E3  : Math Op <<    
Addr : 25CD:             64  : Variable Operation Local Offset - 1 Read
Addr : 25CE:          37 37  : Constant Mask Y=55 Decrement 00FFFFFF 16777215
Addr : 25D0:             E8  : Math Op &     
Addr : 25D1:             EA  : Math Op |     
Addr : 25D2:             44  : Variable Operation Global Offset - 1 Read
Addr : 25D3:             35  : Constant 1 $00000000
Addr : 25D4:             D1  : Memory Op Long POP Address POP Index WRITE 
Addr : 25D5: Label0005
188                        repeat while long[control][0] & ioTestRdy            ' Wait for this to finish
Addr : 25D5:             44  : Variable Operation Global Offset - 1 Read
Addr : 25D6:             35  : Constant 1 $00000000
Addr : 25D7:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 25D8: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 25DD:             E8  : Math Op &     
Addr : 25DE: JZ Label0007
Addr : 25DE:          0A 02  : jz Address = 25E2 2
Addr : 25E0: Label0006
Addr : 25E0: JMP Label0005
Addr : 25E0:          04 73  : Jmp 25D5 -13  
Addr : 25E2: Label0007
189                        return (long[control][0] & ioTestErr) <> 0           ' Return any error code
Addr : 25E2:             44  : Variable Operation Global Offset - 1 Read
Addr : 25E3:             35  : Constant 1 $00000000
Addr : 25E4:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 25E5:          37 1E  : Constant Mask Y=30 80000000 2147483648
Addr : 25E7:             E8  : Math Op &     
Addr : 25E8:             35  : Constant 1 $00000000
Addr : 25E9:             FB  : Math Op <>    
Addr : 25EA:             33  : Return value  
Addr : 25EB: Data : 32                       2
|===========================================================================|
Spin Block writeSDCard with 3 Parameters and 0 Extra Stack Longs. Method 7
PUB writeSDCard(addr,buffer,count)                     '' Write block(s) to SD card from RAM

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - addr
Local Parameter DBASE:0008 - buffer
Local Parameter DBASE:000C - count
|===========================================================================|
192                        repeat while long[control][0] & ioTestRdy            ' Wait for previous I/O to finish
Addr : 25EC: Label0002
Addr : 25EC:             44  : Variable Operation Global Offset - 1 Read
Addr : 25ED:             35  : Constant 1 $00000000
Addr : 25EE:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 25EF: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 25F4:             E8  : Math Op &     
Addr : 25F5: JZ Label0004
Addr : 25F5:          0A 02  : jz Address = 25F9 2
Addr : 25F7: Label0003
Addr : 25F7: JMP Label0002
Addr : 25F7:          04 73  : Jmp 25EC -13  
Addr : 25F9: Label0004
193                        long[control][1] := (count << 16) | (buffer & $FFFF)
Addr : 25F9:             6C  : Variable Operation Local Offset - 3 Read
Addr : 25FA:          37 03  : Constant Mask Y=3 00000010 16
Addr : 25FC:             E3  : Math Op <<    
Addr : 25FD:             68  : Variable Operation Local Offset - 2 Read
Addr : 25FE:          37 2F  : Constant Mask Y=47 Decrement 0000FFFF 65535
Addr : 2600:             E8  : Math Op &     
Addr : 2601:             EA  : Math Op |     
Addr : 2602:             44  : Variable Operation Global Offset - 1 Read
Addr : 2603:             36  : Constant 2 $00000001
Addr : 2604:             D1  : Memory Op Long POP Address POP Index WRITE 
194                        long[control][0] := (ioSpiWrite << 24) | (addr & $FFFFFF)
Addr : 2605:          38 13  : Constant 1 Bytes - 13 - $00000013 19
Addr : 2607:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 2609:             E3  : Math Op <<    
Addr : 260A:             64  : Variable Operation Local Offset - 1 Read
Addr : 260B:          37 37  : Constant Mask Y=55 Decrement 00FFFFFF 16777215
Addr : 260D:             E8  : Math Op &     
Addr : 260E:             EA  : Math Op |     
Addr : 260F:             44  : Variable Operation Global Offset - 1 Read
Addr : 2610:             35  : Constant 1 $00000000
Addr : 2611:             D1  : Memory Op Long POP Address POP Index WRITE 
Addr : 2612: Label0005
195                        repeat while long[control][0] & ioTestRdy            ' Wait for this to finish
Addr : 2612:             44  : Variable Operation Global Offset - 1 Read
Addr : 2613:             35  : Constant 1 $00000000
Addr : 2614:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2615: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 261A:             E8  : Math Op &     
Addr : 261B: JZ Label0007
Addr : 261B:          0A 02  : jz Address = 261F 2
Addr : 261D: Label0006
Addr : 261D: JMP Label0005
Addr : 261D:          04 73  : Jmp 2612 -13  
Addr : 261F: Label0007
196                        return (long[control][0] & ioTestErr) <> 0           ' Return any error code
Addr : 261F:             44  : Variable Operation Global Offset - 1 Read
Addr : 2620:             35  : Constant 1 $00000000
Addr : 2621:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2622:          37 1E  : Constant Mask Y=30 80000000 2147483648
Addr : 2624:             E8  : Math Op &     
Addr : 2625:             35  : Constant 1 $00000000
Addr : 2626:             FB  : Math Op <>    
Addr : 2627:             33  : Return value  
Addr : 2628: Data : 32                       2
|===========================================================================|
Spin Block bootSDCard with 2 Parameters and 1 Extra Stack Longs. Method 8
PUB bootSDCard(addr,count) | t                         '' Boot from an SD card

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - addr
Local Parameter DBASE:0008 - count
Local Variable  DBASE:000C - t
|===========================================================================|
199                        if count < 16                                        ' Must load at least 16 bytes
Addr : 2629:             68  : Variable Operation Local Offset - 2 Read
Addr : 262A:          37 03  : Constant Mask Y=3 00000010 16
Addr : 262C:             F9  : Math Op <     
Addr : 262D: JZ Label0002
Addr : 262D:          0A 02  : jz Address = 2631 2
200                          return true
Addr : 262F:             34  : Constant 0 $FFFFFFFF
Addr : 2630:             33  : Return value  
Addr : 2631: Label0002
Addr : 2631: Label0003
201                        repeat t from 0 to 7                                 ' Stop all COGs except this one and
Addr : 2631:             35  : Constant 1 $00000000
Addr : 2632:             6D  : Variable Operation Local Offset - 3 Write
Addr : 2633: Label0004
202                          if (t <> cogid) and (t <> (cog-1))                 '  the one with the I2C/SPI driver
Addr : 2633:             6C  : Variable Operation Local Offset - 3 Read
Addr : 2634:          3F 89  : Register op $1E9 Read
Addr : 2636:             FB  : Math Op <>    
Addr : 2637:             6C  : Variable Operation Local Offset - 3 Read
Addr : 2638:             40  : Variable Operation Global Offset - 0 Read
Addr : 2639:             36  : Constant 2 $00000001
Addr : 263A:             ED  : Math Op -     
Addr : 263B:             FB  : Math Op <>    
Addr : 263C:             F0  : Math Op AND   
Addr : 263D: JZ Label0007
Addr : 263D:          0A 02  : jz Address = 2641 2
203                              cogstop(t)
Addr : 263F:             6C  : Variable Operation Local Offset - 3 Read
Addr : 2640:             21  : CogStop(id)   
Addr : 2641: Label0007
Addr : 2641: Label0008
Addr : 2641: Label0005
201                        repeat t from 0 to 7                                 ' Stop all COGs except this one and
Addr : 2641:             35  : Constant 1 $00000000
Addr : 2642:          37 22  : Constant Mask Y=34 Decrement 00000007 7
Addr : 2644: Repeat t Step Label0004
Addr : 2644:       6E 02 6C  : Variable Operation Local Offset - 3 Assign Repeat-Var loop Address= 2633 -20
Addr : 2647: Label0006
204                        t := ioSpiBoot | ioStopLdr | cogid                   ' Tell the SD card driver to load
Addr : 2647:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 2649:          37 06  : Constant Mask Y=6 00000080 128
Addr : 264B:             EA  : Math Op |     
Addr : 264C:          3F 89  : Register op $1E9 Read
Addr : 264E:             EA  : Math Op |     
Addr : 264F:             6D  : Variable Operation Local Offset - 3 Write
205                        long[control][1] := count << 16                      '  into HUB RAM after stopping
Addr : 2650:             68  : Variable Operation Local Offset - 2 Read
Addr : 2651:          37 03  : Constant Mask Y=3 00000010 16
Addr : 2653:             E3  : Math Op <<    
Addr : 2654:             44  : Variable Operation Global Offset - 1 Read
Addr : 2655:             36  : Constant 2 $00000001
Addr : 2656:             D1  : Memory Op Long POP Address POP Index WRITE 
206                        long[control][0] := (t << 24) | (addr & $FFFFFF)     '   this calling cog
Addr : 2657:             6C  : Variable Operation Local Offset - 3 Read
Addr : 2658:          38 18  : Constant 1 Bytes - 18 - $00000018 24
Addr : 265A:             E3  : Math Op <<    
Addr : 265B:             64  : Variable Operation Local Offset - 1 Read
Addr : 265C:          37 37  : Constant Mask Y=55 Decrement 00FFFFFF 16777215
Addr : 265E:             E8  : Math Op &     
Addr : 265F:             EA  : Math Op |     
Addr : 2660:             44  : Variable Operation Global Offset - 1 Read
Addr : 2661:             35  : Constant 1 $00000000
Addr : 2662:             D1  : Memory Op Long POP Address POP Index WRITE 
Addr : 2663: Label0009
207                        repeat while long[control][0] & ioTestRdy            ' Wait for this to finish
Addr : 2663:             44  : Variable Operation Global Offset - 1 Read
Addr : 2664:             35  : Constant 1 $00000000
Addr : 2665:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2666: 3B 1F 00 00 00  : Constant 4 Bytes - 1F 00 00 00 - $1F000000 520093696
Addr : 266B:             E8  : Math Op &     
Addr : 266C: JZ Label000B
Addr : 266C:          0A 02  : jz Address = 2670 2
Addr : 266E: Label000A
Addr : 266E: JMP Label0009
Addr : 266E:          04 73  : Jmp 2663 -13  
Addr : 2670: Label000B
208                        return (long[control][0] & ioTestErr) <> 0           ' Return any error code
Addr : 2670:             44  : Variable Operation Global Offset - 1 Read
Addr : 2671:             35  : Constant 1 $00000000
Addr : 2672:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 2673:          37 1E  : Constant Mask Y=30 80000000 2147483648
Addr : 2675:             E8  : Math Op &     
Addr : 2676:             35  : Constant 1 $00000000
Addr : 2677:             FB  : Math Op <>    
Addr : 2678:             33  : Return value  
Addr : 2679: Data : 32                       2
|===========================================================================|
Spin Block start with 1 Parameters and 1 Extra Stack Longs. Method 9
PUB start(ctrlBlk) | t                                 '' Start the I2C I/O driver (standalone)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - ctrlBlk
Local Variable  DBASE:0008 - t
|===========================================================================|
211                        control := ctrlBlk                                   ''  using address of 2 longs for control
Addr : 267A:             64  : Variable Operation Local Offset - 1 Read
Addr : 267B:             45  : Variable Operation Global Offset - 1 Write
212                        stop                                                 ' Stop a previous copy
Addr : 267C:             01  : Drop Anchor   
Addr : 267D:          05 0A  : Call Sub 10   
213                        computeTimes
Addr : 267F:             01  : Drop Anchor   
Addr : 2680:          05 03  : Call Sub 3    
214                        long[control][0] := 0                                ' Initialize the control block
Addr : 2682:             35  : Constant 1 $00000000
Addr : 2683:             44  : Variable Operation Global Offset - 1 Read
Addr : 2684:             35  : Constant 1 $00000000
Addr : 2685:             D1  : Memory Op Long POP Address POP Index WRITE 
215                        long[control][1] := 0
Addr : 2686:             35  : Constant 1 $00000000
Addr : 2687:             44  : Variable Operation Global Offset - 1 Read
Addr : 2688:             36  : Constant 2 $00000001
Addr : 2689:             D1  : Memory Op Long POP Address POP Index WRITE 
216                        cog := cognew(@i2cEntryPoint,control) + 1            ' Start a new cog with the I2C driver
Addr : 268A:             34  : Constant 0 $FFFFFFFF
Addr : 268B:          C7 34  : Memory Op Long PBASE + ADDRESS Address = 0034
Addr : 268D:             44  : Variable Operation Global Offset - 1 Read
Addr : 268E:             28  : CogInit(Id, Addr, Ptr) Push
Addr : 268F:             36  : Constant 2 $00000001
Addr : 2690:             EC  : Math Op +     
Addr : 2691:             41  : Variable Operation Global Offset - 0 Write
217                        return cog > 0                                       ' Indicate success
Addr : 2692:             40  : Variable Operation Global Offset - 0 Read
Addr : 2693:             35  : Constant 1 $00000000
Addr : 2694:             FA  : Math Op >     
Addr : 2695:             33  : Return value  
Addr : 2696: Data : 32                       2
|===========================================================================|
Spin Block stop with 0 Parameters and 0 Extra Stack Longs. Method 10
PUB stop                                               '' Stop the I2C I/O driver (standalone)

Local Parameter DBASE:0000 - Result
|===========================================================================|
220                        if cog > 0
Addr : 2697:             40  : Variable Operation Global Offset - 0 Read
Addr : 2698:             35  : Constant 1 $00000000
Addr : 2699:             FA  : Math Op >     
Addr : 269A: JZ Label0002
Addr : 269A:          0A 04  : jz Address = 26A0 4
221                          cogstop(cog - 1)
Addr : 269C:             40  : Variable Operation Global Offset - 0 Read
Addr : 269D:             36  : Constant 2 $00000001
Addr : 269E:             ED  : Math Op -     
Addr : 269F:             21  : CogStop(id)   
Addr : 26A0: Label0002
Addr : 26A0: Label0003
Addr : 26A0:             32  : Return        
|===========================================================================|
Spin Block getControl with 1 Parameters and 0 Extra Stack Longs. Method 11
PUB getControl(i)                                      '' Return a long from the control block

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - i
|===========================================================================|
224                        return long[control][i]                              ' Check for operation completed first
Addr : 26A1:             44  : Variable Operation Global Offset - 1 Read
Addr : 26A2:             64  : Variable Operation Local Offset - 1 Read
Addr : 26A3:             D0  : Memory Op Long POP Address POP Index READ 
Addr : 26A4:             33  : Return value  
Addr : 26A5: Data : 32                       2
|===========================================================================|
Spin Block setControl with 2 Parameters and 0 Extra Stack Longs. Method 12
PUB setControl(i,value)                                '' Set value of a long in the control block

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - i
Local Parameter DBASE:0008 - value
|===========================================================================|
227                        long[control][i] := value                            ' Always set the first long last
Addr : 26A6:             68  : Variable Operation Local Offset - 2 Read
Addr : 26A7:             44  : Variable Operation Global Offset - 1 Read
Addr : 26A8:             64  : Variable Operation Local Offset - 1 Read
Addr : 26A9:             D1  : Memory Op Long POP Address POP Index WRITE 
Addr : 26AA:             32  : Return        
|===========================================================================|
Object vmcog_v0_975.spin
Object Base is 26AC
|===========================================================================|
Object Constants
|===========================================================================|
|===========================================================================|
VBASE Global Variables
|===========================================================================|
VBASE : 0000 LONG Size 0004 Variable cmdptr
VBASE : 0004 LONG Size 0004 Variable vaddrptr
VBASE : 0008 LONG Size 0004 Variable dataptr
VBASE : 000C LONG Size 0010 Variable fakebox
VBASE : 001C LONG Size 0004 Variable fdataptr
VBASE : 0020 LONG Size 0004 Variable fcmdptr
|===========================================================================|
Object DAT Blocks
|===========================================================================|
26F0(0000)             |         org   $0
26F0(0000)             | vmcog
26F0(0000) F0 AB BE A0 | init_vm mov   pvmcmd,  par       ' save pointer to mailbox, first word is command
26F4(0001) 04 AA FE 80 |         add   pvmcmd,  #4
26F8(0002) 55 AD BE A0 |         mov   pvmaddr, pvmcmd    ' pvmaddr = pointer to long in hub that holds the vmaddr
26FC(0003) 04 AA FE 80 |         add   pvmcmd,  #4
2700(0004) 55 AF BE A0 |         mov   pvmdata, pvmcmd    ' pdata = pointer to long in hub for byte/word/long to be read/written to/from vm
2704(0005) 08 AA FE 84 |         sub   pvmcmd,  #8
2708(0006) 56 BB BE 08 |         rdlong lastpage, pvmaddr ' on startup vmaddr contains the hub address of theLAST page in the working set
270C(0007) 09 BA FE 28 |         shr    lastpage, #9      ' adjust for 512 byte pages
2710(0008) 57 BD BE 08 |         rdlong numpages, pvmdata ' on startup vmdata contains number of pages in working set
2714(0009) 8E 00 7C 5C |         jmp   #vmflush
2718(000A) 00 00 00 00 | fillme  long  0[128-fillme]     ' first 128 cog locations are used for a direct mapped page table
28F0(0080)             |         fit   128
28F0(0080)             | There are 0 ($000) Longs left in the cog
28F0(0080) 8E 00 7C 5C | flushv  jmp   #vmflush  ' due to above, this is at cog address 256
28F4(0081) B5 00 7C 5C |         jmp   #vmdump
28F8(0082) BD 00 7C 5C |         jmp   #vmreadb
28FC(0083) 0C 01 7C 5C |         jmp   #vmreadw
2900(0084) 10 01 7C 5C |         jmp   #vmreadl
2904(0085) 1C 01 7C 5C |         jmp   #vmwriteb
2908(0086) 1F 01 7C 5C |         jmp   #vmwritew
290C(0087) 22 01 7C 5C |         jmp   #vmwritel
2910(0088) B2 00 7C 5C |         jmp   #vmvirtphys
2914(0089) B4 00 7C 5C |         jmp   #vmphysvirt
2918(008A) 25 01 7C 5C |         jmp   #vmlock
291C(008B) 29 01 7C 5C |         jmp   #vmunlock
2920(008C) 00 FE 03 00 | dmask   long  %0_111111111_000000000
2924(008D) 00 00 00 00 | count2  long  0
2928(008E) 00 20 FD 54 | vmflush movd  vflush,#0
292C(008F) 80 B6 FE A0 |         mov   count,#128
2930(0090) 00 00 FC A0 | vflush  mov   0, #0
2934(0091) 74 21 BD 80 |         add   vflush,dstinc
2938(0092) 90 B6 FE E4 |         djnz  count,#vflush
293C(0093) 5D 2D BD 50 |         movs  vset, lastpage
2940(0094) 00 2C FD 54 |         movd  vset, #0
2944(0095) 5E 1B BD A0 |         mov   count2, numpages
2948(0096) 00 00 FC 50 | vset    movs  0,#0
294C(0097) 96 B0 BE A0 |         mov   vmaddr,vset       ' destination of vset instruction is VM page address!
2950(0098) 8C B0 BE 60 |         and   vmaddr,dmask      ' no need, masked in BSTART
2954(0099) 96 BE BE A0 |         mov   hubaddr,vset      ' low 9 bits of vset is upper bits of hub addr!
2958(009A) 09 BE FE 2C |         shl   hubaddr,#9
295C(009B) 8C BE BE 60 |         and   hubaddr,dmask     ' no need, done in BSTART clear low bits to make hubptr correct
2960(009C) 34 85 FE 5C |         call  #BREAD            ' page in the data
2964(009D) 01 2C FD 80 |         add   vset,#1
2968(009E) 74 2D BD 80 |         add   vset,dstinc
296C(009F) 96 1A FD E4 |         djnz  count2,#vset
2970(00A0) 55 51 3D 08 | waitcmd wrlong zero,pvmcmd
2974(00A1) 55 5D BD 0A | wl        rdlong        vminst, pvmcmd wz ' top 23 bits = address, bottom 9 = command
2978(00A2) AE B0 BE A0 |         mov        vmaddr, vminst
297C(00A3) A1 00 68 5C |  if_z        jmp        #wl
2980(00A4) 09 B0 FE 28 |         shr        vmaddr, #9
2984(00A5) 58 B5 BE A0 |         mov     vmpage, vmaddr
2988(00A6) 09 B4 FE 28 |         shr        vmpage, #9
298C(00A7) 5A 53 BD 50 |         movs        present, vmpage
2990(00A8) 00 00 00 00 | zero    LONG 0                    ' used as a zero constant, plus as NOP for delay slot
2994(00A9) 00 5E BD A2 | present mov     vmentry,0-0 wz    'Z=1 not present, Z=0 present
2998(00AA) FF 5F FD 60 |         and     vmentry, #511
299C(00AB) 09 5E FD 2C |         shl     vmentry, #9       ' vmentry now points to correct hub page
29A0(00AC) 58 5F BD 50 |         movs    vmentry, vmaddr   ' now put in offset - vmentry now is correct hub addr!
29A4(00AD) AE 00 3C 5C | vector        jmp        vminst            ' ignores top 23 bits
29A8(00AE) 00 00 00 00 | vminst  long  0                   ' place holder for handler address
29AC(00AF) 00 00 00 00 | vmentry long  0
29B0(00B0) 00 08 00 00 | rhitcount long 1 << 11
29B4(00B1) 00 08 00 00 | whitcount long 1 << 11
29B8(00B2)             | vmvirtphys
29B8(00B2) 57 5F 3D 08 |         wrlong vmentry, pvmdata
29BC(00B3) A0 00 7C 5C |         jmp   #waitcmd
29C0(00B4)             | vmphysvirt
29C0(00B4) A0 00 7C 5C |         jmp   #waitcmd
29C4(00B5) 00 70 FD 54 | vmdump  movd  dloop,#0
29C8(00B6) 80 B6 FE A0 |         mov   count,#128
29CC(00B7) 57 B1 BE 08 |         rdlong vmaddr, pvmdata
29D0(00B8) 58 01 3C 08 | dloop   wrlong 0,vmaddr
29D4(00B9) 04 B0 FE 80 |         add    vmaddr,#4
29D8(00BA) 74 71 BD 80 |         add    dloop,dstinc
29DC(00BB) B8 B6 FE E4 |         djnz   count,#dloop
29E0(00BC) A0 00 7C 5C |         jmp   #waitcmd
29E4(00BD)             | VMREADB
29E4(00BD) D4 F0 E9 5C |  if_z   call  #BUSERR   ' page in missing vm page
29E8(00BE) AF B8 BE 00 | READM1  rdbyte temp,vmentry
29EC(00BF) 5A 83 BD 54 | RDONE   movd  usec1,vmpage
29F0(00C0) 57 B9 3E 08 |         wrlong temp,pvmdata
29F4(00C1) B0 00 BC 81 | usec1   add   0-0,rhitcount wc
29F8(00C2) C4 A4 F1 5C |   if_c  call  #shr_hits ' divide all hit counts by two, for fairness, if any overflow
29FC(00C3) A0 00 7C 5C |         jmp   #waitcmd
2A00(00C4)             | shr_hits      ' walk through TLB, divide all non-zero hit counts by two
2A00(00C4) 00 8C FD 50 |         movs  jx,#0             ' finding candidate page to sacrifice
2A04(00C5) 00 00 00 00 |         nop
2A08(00C6)             | forj
2A08(00C6) 00 F8 BD A2 | jx      mov   tlbi,0-0 wz
2A0C(00C7) CF 00 68 5C |  if_z   jmp   #nextj
2A10(00C8) C6 9C BD 54 |         movd  updtc,jx
2A14(00C9) FC B8 BE A0 |         mov   temp,tlbi
2A18(00CA) 01 B8 FE 28 |         shr   temp,#1
2A1C(00CB) D3 B8 BE 64 |         andn  temp,elevenbits
2A20(00CC) D3 F8 BD 60 |         and  tlbi,elevenbits
2A24(00CD) 5C F9 BD 68 |         or    tlbi,temp
2A28(00CE) FC 00 BC A0 | updtc   mov   0-0,tlbi
2A2C(00CF) 01 8C FD 80 | nextj   add   jx, #1
2A30(00D0) 80 8C 7D 62 |         and   jx, #128 nr, wz
2A34(00D1) C6 00 68 5C |  if_z   jmp   #forj
2A38(00D2) 00 00 7C 5C | shr_hits_ret  ret
2A3C(00D3) FF 07 00 00 | elevenbits long $07FF
2A40(00D4)             | BUSERR  ' location not mapped to physical memory
2A40(00D4) 00 AE FD 50 |         movs  ix,#0             ' finding candidate page to sacrifice
2A44(00D5) FF F5 FD A0 |         mov   minent,#511       ' minent = 511
2A48(00D6) FB F2 BD A0 |         mov   minacc,bigacc     ' minacc = $FFFFFFFF
2A4C(00D7)             | fori    ' for ix=0 to 127
2A4C(00D7) 00 F8 BD A2 | ix      mov   tlbi,0-0 wz
2A50(00D8) E1 00 68 5C |  if_z   jmp   #nexti
2A54(00D9) 67 F9 3D 62 |         and   tlbi,VM_LOCK nr, wz
2A58(00DA) E1 00 54 5C |  if_nz  jmp   #nexti
2A5C(00DB) FC B8 BE A0 |         mov   temp,tlbi
2A60(00DC) 0B B8 FE 28 |         shr   temp,#11  ' temp is now TLB[ix].accesses
2A64(00DD) F9 B8 3E 85 |         cmp   temp,minacc wc
2A68(00DE) E1 00 4C 5C |  if_nc  jmp   #nexti    ' nope, not smaller
2A6C(00DF) 5C F3 BD A0 |         mov   minacc,temp
2A70(00E0) D7 F4 BD 50 |         movs  minent,ix
2A74(00E1) 01 AE FD 80 | nexti   add   ix, #1
2A78(00E2) 80 AE 7D 62 |         and   ix, #128 nr, wz
2A7C(00E3) D7 00 68 5C |  if_z   jmp   #fori
2A80(00E4) FA CC BD 50 |         movs  gettlbi,minent
2A84(00E5) FA E2 BD 54 |         movd  clrold,minent
2A88(00E6) 00 F8 BD A0 | gettlbi mov   tlbi,0-0
2A8C(00E7) FC 5E BD A0 |         mov   vmentry,tlbi
2A90(00E8) 09 5E FD 2C |         shl   vmentry,#9
2A94(00E9) 58 5F BD 50 |         movs  vmentry,vmaddr    ' make it into a physical address
2A98(00EA) 66 F9 3D 62 |         and   tlbi,VM_DIRTY nr,wz
2A9C(00EB) FC BE BE A0 |         mov   hubaddr,tlbi
2AA0(00EC) 09 BE FE 2C |         shl   hubaddr,#9
2AA4(00ED) F1 00 68 5C |         if_z  jmp #clrold       ' page was clean, just clear old entry
2AA8(00EE) FA B0 BE A0 |         mov   vmaddr,minent
2AAC(00EF) 09 B0 FE 2C |         shl   vmaddr,#9
2AB0(00F0) 43 A9 FE 5C |         call  #BWRITE
2AB4(00F1) 00 00 FC A0 | clrold  mov   0-0,#0            ' clear old version
2AB8(00F2) 5A E9 BD 54 |         movd  setent,vmpage
2ABC(00F3) 68 F9 BD 64 |         andn  tlbi,VM_FLAGS    ' does not work - cannot keep count
2AC0(00F4) FC 00 BC A0 | setent  mov   0-0,tlbi
2AC4(00F5)             | rdin    '   fill TLB[minent].hubaddr with BREAD
2AC4(00F5) 5A B1 BE A0 |         mov   vmaddr,vmpage
2AC8(00F6) 09 B0 FE 2C |         shl   vmaddr,#9
2ACC(00F7) 34 85 FE 5C |         call  #BREAD 'fetch page
2AD0(00F8) 00 00 7C 5C | BUSERR_RET ret
2AD4(00F9) 00 00 00 00 | minacc  LONG  $0        ' current lowest non-locked hit count
2AD8(00FA) 00 00 00 00 | minent  LONG  0         ' if not 511, then it is the TLB entry whose physical page we will re-use
2ADC(00FB) 00 00 40 00 | bigacc  LONG  $00400000 ' impossibly large hit count
2AE0(00FC) 00 00 00 00 | tlbi    LONG  0         ' copy of the sacrificial entry
2AE4(00FD) 00 B8 FE A0 | hitavg  mov   temp,#0
2AE8(00FE) 00 00 FE 50 |         movs  hitloop,#0
2AEC(00FF) 80 B6 FE A0 |         mov   count,#TLBENTRIES
2AF0(0100) 00 1A BD A0 | hitloop mov   count2,0-0
2AF4(0101) 0B 1A FD 28 |         shr   count2,#11
2AF8(0102) 8D B8 BE 80 |         add   temp,count2
2AFC(0103) 01 00 FE 80 |         add   hitloop,#1
2B00(0104) 00 B7 FE E4 |         djnz  count,#hitloop
2B04(0105) 07 B8 FE 28 |         shr   temp,#7
2B08(0106) 0D B8 FE 2C |         shl   temp,#13
2B0C(0107) 5C F9 BD 68 |         or    tlbi,temp ' $$$ NEW
2B10(0108) 00 00 7C 5C | hitavg_ret ret
2B14(0109) 00 00 00 00 | xtemp   long  0
2B18(010A) 00 00 00 00 | xcount  long  0
2B1C(010B) 00 00 00 00 | xcount2 long  0
2B20(010C)             | VMREADW
2B20(010C) D4 F0 E9 5C |  if_z   call  #BUSERR   ' page not present
2B24(010D) 01 B0 7E 62 | READM2  and   vmaddr,#1 nr, wz
2B28(010E) AF B8 BE 04 |         rdword temp,vmentry
2B2C(010F) BF 00 7C 5C |         jmp   #RDONE
2B30(0110)             | VMREADL
2B30(0110) D4 F0 E9 5C |  if_z   call  #BUSERR   ' page not present
2B34(0111) 03 B0 7E 62 | READM4  and   vmaddr,#3 nr, wz
2B38(0112) AF B8 BE 08 |         rdlong temp,vmentry
2B3C(0113) BF 00 7C 5C |         jmp   #RDONE
2B40(0114)             | VMWRCOM
2B40(0114) D4 F0 E9 5C |  if_z   call  #BUSERR   ' page in missing, load vm page
2B44(0115) 57 B9 BE 08 |         rdlong temp,pvmdata
2B48(0116) 5A 31 BE 54 |         movd  wd4,vmpage
2B4C(0117) 5A 33 BE 54 |         movd  usec4,vmpage
2B50(0118) 66 01 BC 68 | wd4     or    0-0,VM_DIRTY ' mark page as dirty
2B54(0119) B1 00 BC 81 | usec4   add   0-0,whitcount wc
2B58(011A) C4 A4 F1 5C |  if_c   call  #shr_hits ' divide all hit counts by two, for fairness, if any overflow
2B5C(011B) 00 00 7C 5C | VMWRCOM_RET ret
2B60(011C) 14 37 FE 5C | VMWRITEB call #VMWRCOM
2B64(011D) AF B8 3E 00 |         wrbyte temp,vmentry
2B68(011E) A0 00 7C 5C |         jmp   #waitcmd
2B6C(011F) 14 37 FE 5C | VMWRITEW call #VMWRCOM
2B70(0120) AF B8 3E 04 |         wrword temp,vmentry
2B74(0121) A0 00 7C 5C |         jmp   #waitcmd
2B78(0122) 14 37 FE 5C | VMWRITEL call #VMWRCOM
2B7C(0123) AF B8 3E 08 |         wrlong temp,vmentry
2B80(0124) A0 00 7C 5C |         jmp   #waitcmd
2B84(0125) 5A 4F BE 54 | vmlock  movd  setl,vmpage
2B88(0126) 00 00 00 00 |         nop
2B8C(0127) 67 01 BC 68 | setl    or    0-0,VM_LOCK
2B90(0128) A0 00 7C 5C |         jmp   #waitcmd
2B94(0129) 5A 57 BE 54 | vmunlock movd  clrl,vmpage
2B98(012A) 00 00 00 00 |         nop
2B9C(012B) 67 01 BC 68 | clrl    or    0-0,VM_LOCK
2BA0(012C) A0 00 7C 5C |         jmp   #waitcmd
2BA4(012D)             | BSTART
2BA4(012D) 58 D3 BE A0 |         mov   addr, vmaddr        'addr = external RAM address
2BA8(012E) 6C D3 BE 60 |         and   addr, addr_mask     'Highest addr = $1FFFF
2BAC(012F) FF D3 FE 64 |         andn  addr, #$1FF         'Clear low bits
2BB0(0130) 5F D7 BE A0 |         mov   ptr, hubaddr        'ptr = hub page address
2BB4(0131) 8C D6 BE 60 |         and   ptr, dmask
2BB8(0132) 74 B7 BE A0 |         mov   count,dstinc        '512 bytes to read/write
2BBC(0133) 00 00 7C 5C | BSTART_RET    ret
2BC0(0134)             | BREAD
2BC0(0134) 2D 67 FE 5C |         call   #BSTART
2BC4(0135) 71 E9 BF A0 |         mov    outa, ram_enable_lo  'Put latch back to SRAM=U23
2BC8(0136) 72 ED BF A0 |         mov    dira, ram_dir_read   'Enable bits (for init & wrblock)
2BCC(0137) 6D E9 BF 6C |         xor    outa, ram_LE_bit     'LE= 1 -> 0 (latch)
2BD0(0138) 72 ED BF A0 |         mov    dira, ram_dir_read   'Setup direction to read
2BD4(0139) 08 D2 FE 2C |         shl    addr,#8              'Shift address 8 bits
2BD8(013A) 6F D3 BE 68 |         or     addr, ram_read       'Add -WE=1 -OE=0
2BDC(013B) 69 E9 BF A0 | :bloop  mov    outa, addr           'pc (shifted 8 bits + -WE=1 -OE=0)
2BE0(013C) 00 D3 FE 80 |         add    addr, #$100          'Next byte in ext RAM AND delay for sram access time
2BE4(013D) F2 D5 BE A0 |         mov    data, ina            'Read SRAM
2BE8(013E) 6B D5 3E 00 |         wrbyte data,ptr             'Save the byte
2BEC(013F) 01 D6 FE 80 |         add    ptr, #1              'Next byte in HUB
2BF0(0140) 3B B7 FE E4 |         djnz   count,#:bloop        'Block done?
2BF4(0141) 00 EC FF A0 |         mov   dira, #0              'Tristate all
2BF8(0142) 00 00 7C 5C | BREAD_RET     ret
2BFC(0143)             | BWRITE
2BFC(0143) 2D 67 FE 5C |         call   #BSTART
2C00(0144) 71 E9 BF A0 |         mov     outa, ram_enable_lo  'Put latch back to SRAM=U23
2C04(0145) 72 ED BF A0 |         mov     dira, ram_dir_read   'Enable bits (for init & wrblock)
2C08(0146) 6D E9 BF 6C |         xor     outa, ram_LE_bit     'LE= 1 -> 0 (latch)
2C0C(0147) 08 D2 FE 2C |         shl    addr, #8              'Shift address 8 bits
2C10(0148) 70 D3 BE 68 |         or     addr, ram_write       'Add -WE=0 -OE=1
2C14(0149) 73 ED BF A0 |         mov    dira, ram_dir_write   'Set data bits to outputs
2C18(014A) 6B D5 BE 00 | :bloop  rdbyte data, ptr             'Get a byte from HUB
2C1C(014B) FF D2 FE 64 |         andn   addr, #$FF
2C20(014C) 6A D3 BE 68 |         or     addr, data            'Add data bits to be written
2C24(014D) 69 E9 BF A0 |         mov    outa, addr            'Output -WE=0 -OE=1, address bits, data bits
2C28(014E) 00 D3 FE 80 |         add    addr, #$100           'Next byte in ext RAM AND 25nS min delay
2C2C(014F) 6E E9 BF 68 |         or     outa, ram_latched     'Set -WE=0->1 -OE=1->1  (end write)
2C30(0150) 01 D6 FE 80 |         add    ptr,#1                'Next byte in HUB
2C34(0151) 4A B7 FE E4 |         djnz   count,#:bloop         'Block done?
2C38(0152) 72 ED BF A0 |         mov    dira, ram_dir_read    'Set data bits to inputs
2C3C(0153) 00 EC FF A0 |         mov   dira, #0               'Tristate all
2C40(0154) 00 00 7C 5C | BWRITE_RET    ret
2C44(0155) 00 00 00 00 | pvmcmd    LONG 0                ' used to hold value of PAR, points at mailbox for VMCOG
2C48(0156) 00 00 00 00 | pvmaddr   LONG 0                ' pointer to hub location containing vmaddr
2C4C(0157) 00 00 00 00 | pvmdata   LONG 0                ' pointer to hub location containing byte/word/long to be read/written
2C50(0158) 00 00 00 00 | vmaddr    LONG 0                ' virtual address, initially $0000-$FFFF, later 24 bit address space
2C54(0159) 00 00 00 00 | vmdata    LONG 0                ' byte/word/long data read or to be written
2C58(015A) 00 00 00 00 | vmpage    LONG 0
2C5C(015B) 00 00 00 00 | count     LONG 0                ' used for DJNZ
2C60(015C) 00 00 00 00 | temp      LONG 0                ' generic temporary variable
2C64(015D) 00 7C 00 00 | lastpage  LONG $7C00            ' last page in the hub to be used for the working set
2C68(015E) 00 00 00 00 | numpages  LONG 0                ' total number of pages in the working set
2C6C(015F) 00 00 00 00 | hubaddr   LONG 0                ' hub memory address to read from or write to
2C70(0160) 00 00 00 00 | totreads  LONG 0,0              ' 64 bit total reads counter
2C74(0161) 00 00 00 00 | 
2C78(0162) 00 00 00 00 | totwrites LONG 0,0              ' 64 bit total writes counter
2C7C(0163) 00 00 00 00 | 
2C80(0164) 00 00 00 00 | pagereads LONG 0                ' total number of page reads
2C84(0165) 00 00 00 00 | pagewrites LONG 0               ' total number of page writes
2C88(0166) 00 02 00 00 | VM_DIRTY  LONG %0000_0000_0000_0000_0000_0010_0000_0000
2C8C(0167) 00 04 00 00 | VM_LOCK   LONG %0000_0000_0000_0000_0000_0100_0000_0000
2C90(0168) 00 06 00 00 | VM_FLAGS  LONG %0000_0000_0000_0000_0000_0110_0000_0000
2C94(0169) 00 00 00 00 | addr      long  0               ' byte address, between 0 and $7FFF
2C98(016A) 00 00 00 00 | data      long  0
2C9C(016B) 00 00 00 00 | ptr       long  0
2CA0(016C) FF FF 01 00 | addr_mask long $1FFFF
2CA4(016D)             | BDATA
2CA4(016D) 00 00 00 08 | ram_LE_bit      long    %00001_00000000000_00000000_00000000 ' LE bit
2CA8(016E) 00 00 00 30 | ram_latched     long    %00110_00000000000_00000000_00000000 ' -WE=1 -OE=1 (LE=0)
2CAC(016F) 00 00 00 20 | ram_read        long    %00100_00000000000_00000000_00000000 ' -WE=1 -OE=0 (LE=0)
2CB0(0170) 00 00 00 10 | ram_write       long    %00010_00000000000_00000000_00000000 ' -WE=0 -OE=1 (LE=0)
2CB4(0171) 00 F8 00 38 | ram_enable_lo   long    %00111_00000000000_11111000_00000000 ' -WE=1 -OE=1 LE=1 + -CE(U23 SRAM) = 0 (A19-20=0)
2CB8(0172) 00 FF FF 3F | ram_dir_read    long    %00111_11111111111_11111111_00000000 ' outputs WE, OE, A0-18, inputs D0-7
2CBC(0173) FF FF FF 3F | ram_dir_write   long    %00111_11111111111_11111111_11111111 ' outputs WE, OE, A0-18, D0-7
2CC0(0174) 00 02 00 00 | dstinc    LONG 512
2CC4(0175)             |           FIT 496               ' out of 496
2CC4(0175)             | There are 123 ($07B) Longs left in the cog
|===========================================================================|
|===========================================================================|
Spin Block start with 3 Parameters and 0 Extra Stack Longs. Method 1
PUB start(mailbox,lastp,nump)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - mailbox
Local Parameter DBASE:0008 - lastp
Local Parameter DBASE:000C - nump
|===========================================================================|
215                        cmdptr   := mailbox
Addr : 2CC4:             64  : Variable Operation Local Offset - 1 Read
Addr : 2CC5:             41  : Variable Operation Global Offset - 0 Write
216                        vaddrptr := mailbox+4
Addr : 2CC6:             64  : Variable Operation Local Offset - 1 Read
Addr : 2CC7:          37 01  : Constant Mask Y=1 00000004 4
Addr : 2CC9:             EC  : Math Op +     
Addr : 2CCA:             45  : Variable Operation Global Offset - 1 Write
217                        dataptr  := mailbox+8
Addr : 2CCB:             64  : Variable Operation Local Offset - 1 Read
Addr : 2CCC:          37 02  : Constant Mask Y=2 00000008 8
Addr : 2CCE:             EC  : Math Op +     
Addr : 2CCF:             49  : Variable Operation Global Offset - 2 Write
219                        long[vaddrptr] := lastp-((nump-1)*512) ' singe byte read/writes are the default
Addr : 2CD0:             68  : Variable Operation Local Offset - 2 Read
Addr : 2CD1:             6C  : Variable Operation Local Offset - 3 Read
Addr : 2CD2:             36  : Constant 2 $00000001
Addr : 2CD3:             ED  : Math Op -     
Addr : 2CD4:          37 08  : Constant Mask Y=8 00000200 512
Addr : 2CD6:             F4  : Math Op *     
Addr : 2CD7:             ED  : Math Op -     
Addr : 2CD8:             44  : Variable Operation Global Offset - 1 Read
Addr : 2CD9:             C1  : Memory Op Long POP Address WRITE 
220                        long[dataptr]  := nump        ' singe byte read/writes are the default
Addr : 2CDA:             6C  : Variable Operation Local Offset - 3 Read
Addr : 2CDB:             48  : Variable Operation Global Offset - 2 Read
Addr : 2CDC:             C1  : Memory Op Long POP Address WRITE 
221                        word[cmdptr]   := $FFFF0000
Addr : 2CDD:          37 6F  : Constant Mask Y=111 Decrement Invert FFFF0000 4294901760
Addr : 2CDF:             40  : Variable Operation Global Offset - 0 Read
Addr : 2CE0:             A1  : Memory Op Word POP Address WRITE 
229                        cognew(@vmcog,mailbox)
Addr : 2CE1:             34  : Constant 0 $FFFFFFFF
Addr : 2CE2:          C7 44  : Memory Op Long PBASE + ADDRESS Address = 0044
Addr : 2CE4:             64  : Variable Operation Local Offset - 1 Read
Addr : 2CE5:             2C  : CogInit(Id, Addr, Ptr)
231                        fcmdptr  := @fakebox
Addr : 2CE6:             4F  : Variable Operation Global Offset - 3 Address
Addr : 2CE7:          C9 20  : Memory Op Long VBASE + WRITE Address = 0020
232                        fdataptr := fcmdptr+4
Addr : 2CE9:          C8 20  : Memory Op Long VBASE + READ Address = 0020
Addr : 2CEB:          37 01  : Constant Mask Y=1 00000004 4
Addr : 2CED:             EC  : Math Op +     
Addr : 2CEE:             5D  : Variable Operation Global Offset - 7 Write
Addr : 2CEF: Label0002
233                        repeat while long[cmdptr]     ' should fix startup bug heater found - it was the delay to load/init the cog
Addr : 2CEF:             40  : Variable Operation Global Offset - 0 Read
Addr : 2CF0:             C0  : Memory Op Long POP Address READ 
Addr : 2CF1: JZ Label0004
Addr : 2CF1:          0A 02  : jz Address = 2CF5 2
Addr : 2CF3: Label0003
Addr : 2CF3: JMP Label0002
Addr : 2CF3:          04 7A  : Jmp 2CEF -6   
Addr : 2CF5: Label0004
Addr : 2CF5:             32  : Return        
|===========================================================================|
Spin Block rdvbyte with 1 Parameters and 0 Extra Stack Longs. Method 2
PUB rdvbyte(adr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
|===========================================================================|
236                        repeat while long[cmdptr]
Addr : 2CF6: Label0002
Addr : 2CF6:             40  : Variable Operation Global Offset - 0 Read
Addr : 2CF7:             C0  : Memory Op Long POP Address READ 
Addr : 2CF8: JZ Label0004
Addr : 2CF8:          0A 02  : jz Address = 2CFC 2
Addr : 2CFA: Label0003
Addr : 2CFA: JMP Label0002
Addr : 2CFA:          04 7A  : Jmp 2CF6 -6   
Addr : 2CFC: Label0004
237                        long[cmdptr] := (adr<<9)|READVMB
Addr : 2CFC:             64  : Variable Operation Local Offset - 1 Read
Addr : 2CFD:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2CFF:             E3  : Math Op <<    
Addr : 2D00:          38 82  : Constant 1 Bytes - 82 - $00000082 130
Addr : 2D02:             EA  : Math Op |     
Addr : 2D03:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D04:             C1  : Memory Op Long POP Address WRITE 
Addr : 2D05: Label0005
238                        repeat while long[cmdptr]
Addr : 2D05:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D06:             C0  : Memory Op Long POP Address READ 
Addr : 2D07: JZ Label0007
Addr : 2D07:          0A 02  : jz Address = 2D0B 2
Addr : 2D09: Label0006
Addr : 2D09: JMP Label0005
Addr : 2D09:          04 7A  : Jmp 2D05 -6   
Addr : 2D0B: Label0007
239                        return long[dataptr]
Addr : 2D0B:             48  : Variable Operation Global Offset - 2 Read
Addr : 2D0C:             C0  : Memory Op Long POP Address READ 
Addr : 2D0D:             33  : Return value  
Addr : 2D0E: Data : 32                       2
|===========================================================================|
Spin Block rdvword with 1 Parameters and 0 Extra Stack Longs. Method 3
PUB rdvword(adr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
|===========================================================================|
242                        repeat while long[cmdptr]
Addr : 2D0F: Label0002
Addr : 2D0F:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D10:             C0  : Memory Op Long POP Address READ 
Addr : 2D11: JZ Label0004
Addr : 2D11:          0A 02  : jz Address = 2D15 2
Addr : 2D13: Label0003
Addr : 2D13: JMP Label0002
Addr : 2D13:          04 7A  : Jmp 2D0F -6   
Addr : 2D15: Label0004
243                        long[cmdptr] := (adr<<9)|READVMW
Addr : 2D15:             64  : Variable Operation Local Offset - 1 Read
Addr : 2D16:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2D18:             E3  : Math Op <<    
Addr : 2D19:          38 83  : Constant 1 Bytes - 83 - $00000083 131
Addr : 2D1B:             EA  : Math Op |     
Addr : 2D1C:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D1D:             C1  : Memory Op Long POP Address WRITE 
Addr : 2D1E: Label0005
244                        repeat while long[cmdptr]
Addr : 2D1E:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D1F:             C0  : Memory Op Long POP Address READ 
Addr : 2D20: JZ Label0007
Addr : 2D20:          0A 02  : jz Address = 2D24 2
Addr : 2D22: Label0006
Addr : 2D22: JMP Label0005
Addr : 2D22:          04 7A  : Jmp 2D1E -6   
Addr : 2D24: Label0007
245                        return long[dataptr]
Addr : 2D24:             48  : Variable Operation Global Offset - 2 Read
Addr : 2D25:             C0  : Memory Op Long POP Address READ 
Addr : 2D26:             33  : Return value  
Addr : 2D27: Data : 32                       2
|===========================================================================|
Spin Block rdvlong with 1 Parameters and 0 Extra Stack Longs. Method 4
PUB rdvlong(adr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
|===========================================================================|
248                        repeat while long[cmdptr]
Addr : 2D28: Label0002
Addr : 2D28:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D29:             C0  : Memory Op Long POP Address READ 
Addr : 2D2A: JZ Label0004
Addr : 2D2A:          0A 02  : jz Address = 2D2E 2
Addr : 2D2C: Label0003
Addr : 2D2C: JMP Label0002
Addr : 2D2C:          04 7A  : Jmp 2D28 -6   
Addr : 2D2E: Label0004
249                        long[cmdptr] := (adr<<9)|READVML
Addr : 2D2E:             64  : Variable Operation Local Offset - 1 Read
Addr : 2D2F:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2D31:             E3  : Math Op <<    
Addr : 2D32:          38 84  : Constant 1 Bytes - 84 - $00000084 132
Addr : 2D34:             EA  : Math Op |     
Addr : 2D35:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D36:             C1  : Memory Op Long POP Address WRITE 
Addr : 2D37: Label0005
250                        repeat while long[cmdptr]
Addr : 2D37:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D38:             C0  : Memory Op Long POP Address READ 
Addr : 2D39: JZ Label0007
Addr : 2D39:          0A 02  : jz Address = 2D3D 2
Addr : 2D3B: Label0006
Addr : 2D3B: JMP Label0005
Addr : 2D3B:          04 7A  : Jmp 2D37 -6   
Addr : 2D3D: Label0007
251                        return long[dataptr]
Addr : 2D3D:             48  : Variable Operation Global Offset - 2 Read
Addr : 2D3E:             C0  : Memory Op Long POP Address READ 
Addr : 2D3F:             33  : Return value  
Addr : 2D40: Data : 32                       2
|===========================================================================|
Spin Block wrvbyte with 2 Parameters and 0 Extra Stack Longs. Method 5
PUB wrvbyte(adr,dt)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
Local Parameter DBASE:0008 - dt
|===========================================================================|
254                        repeat while long[cmdptr]
Addr : 2D41: Label0002
Addr : 2D41:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D42:             C0  : Memory Op Long POP Address READ 
Addr : 2D43: JZ Label0004
Addr : 2D43:          0A 02  : jz Address = 2D47 2
Addr : 2D45: Label0003
Addr : 2D45: JMP Label0002
Addr : 2D45:          04 7A  : Jmp 2D41 -6   
Addr : 2D47: Label0004
255                        long[dataptr]  := dt
Addr : 2D47:             68  : Variable Operation Local Offset - 2 Read
Addr : 2D48:             48  : Variable Operation Global Offset - 2 Read
Addr : 2D49:             C1  : Memory Op Long POP Address WRITE 
256                        long[cmdptr] := (adr<<9)|WRITEVMB
Addr : 2D4A:             64  : Variable Operation Local Offset - 1 Read
Addr : 2D4B:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2D4D:             E3  : Math Op <<    
Addr : 2D4E:          38 85  : Constant 1 Bytes - 85 - $00000085 133
Addr : 2D50:             EA  : Math Op |     
Addr : 2D51:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D52:             C1  : Memory Op Long POP Address WRITE 
Addr : 2D53: Label0005
257                        repeat while long[cmdptr]
Addr : 2D53:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D54:             C0  : Memory Op Long POP Address READ 
Addr : 2D55: JZ Label0007
Addr : 2D55:          0A 02  : jz Address = 2D59 2
Addr : 2D57: Label0006
Addr : 2D57: JMP Label0005
Addr : 2D57:          04 7A  : Jmp 2D53 -6   
Addr : 2D59: Label0007
Addr : 2D59:             32  : Return        
|===========================================================================|
Spin Block wrvword with 2 Parameters and 0 Extra Stack Longs. Method 6
PUB wrvword(adr,dt)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
Local Parameter DBASE:0008 - dt
|===========================================================================|
260                        repeat while long[cmdptr]
Addr : 2D5A: Label0002
Addr : 2D5A:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D5B:             C0  : Memory Op Long POP Address READ 
Addr : 2D5C: JZ Label0004
Addr : 2D5C:          0A 02  : jz Address = 2D60 2
Addr : 2D5E: Label0003
Addr : 2D5E: JMP Label0002
Addr : 2D5E:          04 7A  : Jmp 2D5A -6   
Addr : 2D60: Label0004
261                        long[dataptr]  := dt
Addr : 2D60:             68  : Variable Operation Local Offset - 2 Read
Addr : 2D61:             48  : Variable Operation Global Offset - 2 Read
Addr : 2D62:             C1  : Memory Op Long POP Address WRITE 
262                        long[cmdptr] := (adr<<9)|WRITEVMW
Addr : 2D63:             64  : Variable Operation Local Offset - 1 Read
Addr : 2D64:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2D66:             E3  : Math Op <<    
Addr : 2D67:          38 86  : Constant 1 Bytes - 86 - $00000086 134
Addr : 2D69:             EA  : Math Op |     
Addr : 2D6A:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D6B:             C1  : Memory Op Long POP Address WRITE 
Addr : 2D6C: Label0005
263                        repeat while long[cmdptr]
Addr : 2D6C:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D6D:             C0  : Memory Op Long POP Address READ 
Addr : 2D6E: JZ Label0007
Addr : 2D6E:          0A 02  : jz Address = 2D72 2
Addr : 2D70: Label0006
Addr : 2D70: JMP Label0005
Addr : 2D70:          04 7A  : Jmp 2D6C -6   
Addr : 2D72: Label0007
Addr : 2D72:             32  : Return        
|===========================================================================|
Spin Block wrvlong with 2 Parameters and 0 Extra Stack Longs. Method 7
PUB wrvlong(adr,dt)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
Local Parameter DBASE:0008 - dt
|===========================================================================|
266                        repeat while long[cmdptr]
Addr : 2D73: Label0002
Addr : 2D73:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D74:             C0  : Memory Op Long POP Address READ 
Addr : 2D75: JZ Label0004
Addr : 2D75:          0A 02  : jz Address = 2D79 2
Addr : 2D77: Label0003
Addr : 2D77: JMP Label0002
Addr : 2D77:          04 7A  : Jmp 2D73 -6   
Addr : 2D79: Label0004
267                        long[dataptr]  := dt
Addr : 2D79:             68  : Variable Operation Local Offset - 2 Read
Addr : 2D7A:             48  : Variable Operation Global Offset - 2 Read
Addr : 2D7B:             C1  : Memory Op Long POP Address WRITE 
268                        long[cmdptr] := (adr<<9)|WRITEVML
Addr : 2D7C:             64  : Variable Operation Local Offset - 1 Read
Addr : 2D7D:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2D7F:             E3  : Math Op <<    
Addr : 2D80:          38 87  : Constant 1 Bytes - 87 - $00000087 135
Addr : 2D82:             EA  : Math Op |     
Addr : 2D83:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D84:             C1  : Memory Op Long POP Address WRITE 
Addr : 2D85: Label0005
269                        repeat while long[cmdptr]
Addr : 2D85:             40  : Variable Operation Global Offset - 0 Read
Addr : 2D86:             C0  : Memory Op Long POP Address READ 
Addr : 2D87: JZ Label0007
Addr : 2D87:          0A 02  : jz Address = 2D8B 2
Addr : 2D89: Label0006
Addr : 2D89: JMP Label0005
Addr : 2D89:          04 7A  : Jmp 2D85 -6   
Addr : 2D8B: Label0007
Addr : 2D8B:             32  : Return        
|===========================================================================|
Spin Block rdfbyte with 1 Parameters and 0 Extra Stack Longs. Method 8
PUB rdfbyte(adr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
|===========================================================================|
272                        repeat while 0
Addr : 2D8C: Label0002
Addr : 2D8C:             35  : Constant 1 $00000000
Addr : 2D8D: JZ Label0004
Addr : 2D8D:          0A 02  : jz Address = 2D91 2
Addr : 2D8F: Label0003
Addr : 2D8F: JMP Label0002
Addr : 2D8F:          04 7B  : Jmp 2D8C -5   
Addr : 2D91: Label0004
273                        long[fcmdptr] := (adr<<9)|READVMB
Addr : 2D91:             64  : Variable Operation Local Offset - 1 Read
Addr : 2D92:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2D94:             E3  : Math Op <<    
Addr : 2D95:          38 82  : Constant 1 Bytes - 82 - $00000082 130
Addr : 2D97:             EA  : Math Op |     
Addr : 2D98:          C8 20  : Memory Op Long VBASE + READ Address = 0020
Addr : 2D9A:             C1  : Memory Op Long POP Address WRITE 
Addr : 2D9B: Label0005
274                        repeat while 0
Addr : 2D9B:             35  : Constant 1 $00000000
Addr : 2D9C: JZ Label0007
Addr : 2D9C:          0A 02  : jz Address = 2DA0 2
Addr : 2D9E: Label0006
Addr : 2D9E: JMP Label0005
Addr : 2D9E:          04 7B  : Jmp 2D9B -5   
Addr : 2DA0: Label0007
275                        return 0
Addr : 2DA0:             35  : Constant 1 $00000000
Addr : 2DA1:             33  : Return value  
Addr : 2DA2: Data : 32                       2
|===========================================================================|
Spin Block wrfbyte with 2 Parameters and 0 Extra Stack Longs. Method 9
PUB wrfbyte(adr,dt)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
Local Parameter DBASE:0008 - dt
|===========================================================================|
278                        repeat while 0
Addr : 2DA3: Label0002
Addr : 2DA3:             35  : Constant 1 $00000000
Addr : 2DA4: JZ Label0004
Addr : 2DA4:          0A 02  : jz Address = 2DA8 2
Addr : 2DA6: Label0003
Addr : 2DA6: JMP Label0002
Addr : 2DA6:          04 7B  : Jmp 2DA3 -5   
Addr : 2DA8: Label0004
279                        long[fdataptr]  := dt
Addr : 2DA8:             68  : Variable Operation Local Offset - 2 Read
Addr : 2DA9:             5C  : Variable Operation Global Offset - 7 Read
Addr : 2DAA:             C1  : Memory Op Long POP Address WRITE 
280                        long[fcmdptr] := (adr<<9)|WRITEVMB
Addr : 2DAB:             64  : Variable Operation Local Offset - 1 Read
Addr : 2DAC:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2DAE:             E3  : Math Op <<    
Addr : 2DAF:          38 85  : Constant 1 Bytes - 85 - $00000085 133
Addr : 2DB1:             EA  : Math Op |     
Addr : 2DB2:          C8 20  : Memory Op Long VBASE + READ Address = 0020
Addr : 2DB4:             C1  : Memory Op Long POP Address WRITE 
Addr : 2DB5: Label0005
281                        repeat while 0
Addr : 2DB5:             35  : Constant 1 $00000000
Addr : 2DB6: JZ Label0007
Addr : 2DB6:          0A 02  : jz Address = 2DBA 2
Addr : 2DB8: Label0006
Addr : 2DB8: JMP Label0005
Addr : 2DB8:          04 7B  : Jmp 2DB5 -5   
Addr : 2DBA: Label0007
Addr : 2DBA:             32  : Return        
|===========================================================================|
Spin Block Flush with 0 Parameters and 0 Extra Stack Longs. Method 10
PUB Flush

Local Parameter DBASE:0000 - Result
|===========================================================================|
284                        repeat while long[cmdptr]
Addr : 2DBB: Label0002
Addr : 2DBB:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DBC:             C0  : Memory Op Long POP Address READ 
Addr : 2DBD: JZ Label0004
Addr : 2DBD:          0A 02  : jz Address = 2DC1 2
Addr : 2DBF: Label0003
Addr : 2DBF: JMP Label0002
Addr : 2DBF:          04 7A  : Jmp 2DBB -6   
Addr : 2DC1: Label0004
285                        word[cmdptr]   := FLUSHVM
Addr : 2DC1:          37 06  : Constant Mask Y=6 00000080 128
Addr : 2DC3:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DC4:             A1  : Memory Op Word POP Address WRITE 
Addr : 2DC5: Label0005
286                        repeat while long[cmdptr]
Addr : 2DC5:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DC6:             C0  : Memory Op Long POP Address READ 
Addr : 2DC7: JZ Label0007
Addr : 2DC7:          0A 02  : jz Address = 2DCB 2
Addr : 2DC9: Label0006
Addr : 2DC9: JMP Label0005
Addr : 2DC9:          04 7A  : Jmp 2DC5 -6   
Addr : 2DCB: Label0007
287                        return
Addr : 2DCB:             32  : Return        
Addr : 2DCC: Data : 32                       2
|===========================================================================|
Spin Block Look with 1 Parameters and 0 Extra Stack Longs. Method 11
PUB Look(adr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
|===========================================================================|
290                        repeat while long[cmdptr]
Addr : 2DCD: Label0002
Addr : 2DCD:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DCE:             C0  : Memory Op Long POP Address READ 
Addr : 2DCF: JZ Label0004
Addr : 2DCF:          0A 02  : jz Address = 2DD3 2
Addr : 2DD1: Label0003
Addr : 2DD1: JMP Label0002
Addr : 2DD1:          04 7A  : Jmp 2DCD -6   
Addr : 2DD3: Label0004
291                        long[dataptr]   := adr
Addr : 2DD3:             64  : Variable Operation Local Offset - 1 Read
Addr : 2DD4:             48  : Variable Operation Global Offset - 2 Read
Addr : 2DD5:             C1  : Memory Op Long POP Address WRITE 
292                        long[cmdptr]    := DUMPVM
Addr : 2DD6:          38 81  : Constant 1 Bytes - 81 - $00000081 129
Addr : 2DD8:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DD9:             C1  : Memory Op Long POP Address WRITE 
Addr : 2DDA: Label0005
293                        repeat while long[cmdptr]
Addr : 2DDA:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DDB:             C0  : Memory Op Long POP Address READ 
Addr : 2DDC: JZ Label0007
Addr : 2DDC:          0A 02  : jz Address = 2DE0 2
Addr : 2DDE: Label0006
Addr : 2DDE: JMP Label0005
Addr : 2DDE:          04 7A  : Jmp 2DDA -6   
Addr : 2DE0: Label0007
294                        return
Addr : 2DE0:             32  : Return        
Addr : 2DE1: Data : 32                       2
|===========================================================================|
Spin Block GetPhysVirt with 1 Parameters and 0 Extra Stack Longs. Method 12
PUB GetPhysVirt(vaddr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - vaddr
|===========================================================================|
297                        repeat while long[cmdptr]
Addr : 2DE2: Label0002
Addr : 2DE2:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DE3:             C0  : Memory Op Long POP Address READ 
Addr : 2DE4: JZ Label0004
Addr : 2DE4:          0A 02  : jz Address = 2DE8 2
Addr : 2DE6: Label0003
Addr : 2DE6: JMP Label0002
Addr : 2DE6:          04 7A  : Jmp 2DE2 -6   
Addr : 2DE8: Label0004
298                        long[cmdptr] := (vaddr<<9)|VIRTPHYS
Addr : 2DE8:             64  : Variable Operation Local Offset - 1 Read
Addr : 2DE9:          38 09  : Constant 1 Bytes - 09 - $00000009 9
Addr : 2DEB:             E3  : Math Op <<    
Addr : 2DEC:          38 88  : Constant 1 Bytes - 88 - $00000088 136
Addr : 2DEE:             EA  : Math Op |     
Addr : 2DEF:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DF0:             C1  : Memory Op Long POP Address WRITE 
Addr : 2DF1: Label0005
299                        repeat while long[cmdptr]
Addr : 2DF1:             40  : Variable Operation Global Offset - 0 Read
Addr : 2DF2:             C0  : Memory Op Long POP Address READ 
Addr : 2DF3: JZ Label0007
Addr : 2DF3:          0A 02  : jz Address = 2DF7 2
Addr : 2DF5: Label0006
Addr : 2DF5: JMP Label0005
Addr : 2DF5:          04 7A  : Jmp 2DF1 -6   
Addr : 2DF7: Label0007
300                        return long[dataptr]
Addr : 2DF7:             48  : Variable Operation Global Offset - 2 Read
Addr : 2DF8:             C0  : Memory Op Long POP Address READ 
Addr : 2DF9:             33  : Return value  
Addr : 2DFA: Data : 32                       2
|===========================================================================|
Spin Block GetVirtLoadAddr with 1 Parameters and 1 Extra Stack Longs. Method 13
PUB GetVirtLoadAddr(vaddr)|va

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - vaddr
Local Variable  DBASE:0008 - va
|===========================================================================|
303                        va:= vaddr&$7FFE00         ' 23 bit VM address - force start of page
Addr : 2DFB:             64  : Variable Operation Local Offset - 1 Read
Addr : 2DFC:    3A 7F FE 00  : Constant 3 Bytes - 7F FE 00 - $007FFE00 8388096
Addr : 2E00:             E8  : Math Op &     
Addr : 2E01:             69  : Variable Operation Local Offset - 2 Write
304                        wrvbyte(vaddr,rdvbyte(va)) ' force page into working set, set dirty bit
Addr : 2E02:             01  : Drop Anchor   
Addr : 2E03:             64  : Variable Operation Local Offset - 1 Read
Addr : 2E04:             00  : Drop Anchor Push 
Addr : 2E05:             68  : Variable Operation Local Offset - 2 Read
Addr : 2E06:          05 02  : Call Sub 2    
Addr : 2E08:          05 05  : Call Sub 5    
305                        return GetPhysVirt(va)     ' note returned pointer only valid until next vm call
Addr : 2E0A:             00  : Drop Anchor Push 
Addr : 2E0B:             68  : Variable Operation Local Offset - 2 Read
Addr : 2E0C:          05 0C  : Call Sub 12   
Addr : 2E0E:             33  : Return value  
Addr : 2E0F: Data : 32                       2
|===========================================================================|
Spin Block GetVirtPhys with 1 Parameters and 0 Extra Stack Longs. Method 14
PUB GetVirtPhys(adr)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - adr
|===========================================================================|
309                        return 0
Addr : 2E10:             35  : Constant 1 $00000000
Addr : 2E11:             33  : Return value  
Addr : 2E12: Data : 32                       2
|===========================================================================|
Spin Block Lock with 2 Parameters and 0 Extra Stack Longs. Method 15
PUB Lock(vaddr,pages) ' should be called after Flush, before any other access

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - vaddr
Local Parameter DBASE:0008 - pages
|===========================================================================|
312                        return 0
Addr : 2E13:             35  : Constant 1 $00000000
Addr : 2E14:             33  : Return value  
Addr : 2E15: Data : 32                       2
|===========================================================================|
Spin Block Unlock with 2 Parameters and 0 Extra Stack Longs. Method 16
PUB Unlock(vaddr,page)

Local Parameter DBASE:0000 - Result
Local Parameter DBASE:0004 - vaddr
Local Parameter DBASE:0008 - page
|===========================================================================|
315                        return 0
Addr : 2E16:             35  : Constant 1 $00000000
Addr : 2E17:             33  : Return value  
Addr : 2E18: Data : 32                       2
