DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 DFS Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 DFS Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download

⟦96d112a82⟧ M200

    Length: 5632 (0x1600)
    Types: M200
    Notes: M200_PROGRAM
    Names: »STAT.M200«

Derivation

└─⟦24d56d853⟧ Bits:30000744 8mm tape, Rational 1000, DFS, D_12_6_5 SEQ293
    └─ ⟦this⟧ »STAT.M200« 

Disassembly

0x20562


@ 20562
    <POP 20562-205c4 Body>                                              
        <POP 20562-20578 Prologue>                           Σ0         ↓
        <POP 20578-20580 RegCacheLoad>                       Σ0         ↓
        <POP 20580-20582 Naked>                              Σ0         ↓
            <MI 20580  MOVEQ.L #0x00,D7>                                        {}
        <POP 20582-2059c Naked>                              Σ0         ↓ →0x20582 ←0x20582
            <POP 0x20582 LimitCheck 0x0 ≤ D7 ≤ 0x10>                            {}
            <MI 20588  MOVE.L  D7,D0>                                           {}
            <MI 2058a  ASL.L   #0x2,D0>                                         {}
            <MI 2058c  LEA.L   0x2146c,A0>                                      {}
            <MI 2058e  LEA.L   (A0+D0.L),A0>                                    {}
            <MI 20592  CLR.L   (A0+0x500c)>                                     {}
            <MI 20596  ADDQ.L  #0x1,D7>                                         {}
            <MI 20598  CMP.L   #0x10,D7>                                        {}
            <MI 2059a  BLE     0x20582>                                         {}
        <POP 2059c-2059e Naked>                              Σ0         ↓
            <MI 2059c  MOVEQ.L #0x00,D7>                                        {}
        <POP 2059e-205bc Naked>                              Σ0         ↓ →0x2059e ←0x2059e
            <POP 0x2059e LimitCheck 0x0 ≤ D7 ≤ 0x1fff>                          {}
            <MI 205a8  MOVE.L  D7,D0>                                           {}
            <MI 205aa  ASL.L   #0x1,D0>                                         {}
            <MI 205ac  LEA.L   0x2146c,A0>                                      {}
            <MI 205ae  CLR.W   (A0+D0.L+#0x8)>                                  {}
            <MI 205b2  ADDQ.L  #0x1,D7>                                         {}
            <MI 205b4  CMPI.L  #0x00001fff,D7>                                  {}
            <MI 205ba  BLE     0x2059e>                                         {}
        <POP 205bc-205c4 Epilogue>                           Σ0         

0x205c4


@ 205c4
        <LVAR -0x002 2(rw)>
        <LVAR -0x004 2(rw)>
        <LVAR -0x3e1 1(r)>
        <LVAR -0x3e2 1(r)>
        <LVAR -0x3e4 2(r)>
        <LVAR -0x3e5 1(r)>
        <LVAR -0x3e6 1(r)>
        <LVAR -0x3e8 2(r)>
        <LVAR -0x404 @>
    <POP 205c4-207b6 Body>                                              
        <POP 205c4-205da Prologue>                           Σ0         ↓
        <POP 205da-205ec RegCacheLoad>                       Σ0         ↓
        <POP 205ec-20620 Naked>                              Σ0         ↓
            <Blob 0x205ec [26] @>                            Δ-26               {[«26""»]}
            <POP 205fe-20600 StackAdj>                       Δ-4                {[«26""»]|[-4-]}
            <Lit 0x20600 25>                                                    {[«26""»]|[$$Loading directory blocks.]}
            <Call 0x20614 0x103e0>                                              {[«26""»]|[$$Loading directory blocks.]}
                WriteConsoleStringCrLf(str : String)
            <POP 2061a-2061e StackAdj>                       Δ+30               {}
            <MI 2061e  MOVEQ.L #0x00,D6>                                        {}
        <POP 20620-20654 Naked>                              Σ0 Δ-4     ↓ →0x2065c ←0x20682
            <POP 0x20620 LimitCheck 0x0 ≤ D6 ≤ 0x7>                             {}
            <MI 2062a  MOVE.L  D6,D0>                                           {}
            <MI 2062c  ASL.L   #0x1,D0>                                         {}
            <MI 2062e  LEA.L   0x0,A0>                                          {}
            <MI 20632  LEA.L   (A0+D0.L),A0>                                    {}
            <MI 20636  ADDA.L  #0x10012,A0>                                     {}
            <MI 2063c  MOVE.W  (A0),D5>                                         {}
            <MI 2063e  CLR.L   D0>                                              {}
            <MI 20640  MOVE.W  D5,D0>                                           {}
            <MI 20642  ADDI.L  #0x000000ff,D0>                                  {}
            <MI 20648  MOVE.L  D0,-(A7)>                     Δ-4                {[4, 'D0']}
            <MI 2064a  CLR.L   D0>                                              {[4, 'D0']}
            <MI 2064c  MOVE.W  D5,D0>                                           {[4, 'D0']}
            <MI 2064e  MOVE.L  D0,D7>                                           {[4, 'D0']}
            <MI 20650  CMP.L   (A7),D7>                                         {[4, 'D0']}
            <MI 20652  BHI     0x2065c>                                         {[4, 'D0']}
        <POP 20654-2065a Naked>                              Σ-4        →0x2065c
            <MI 20654  MOVE.L  (A7),D0>                                         {[-4-]}
            <MI 20656  CMP.L   D0,D7>                                           {[-4-]}
            <MI 20658  BLT     0x2065c>                                         {[-4-]}
        <POP 2065a-2065c Naked>                              Σ0         
            <MI 2065a  TRAP    #15>                                             {}
        <POP 2065c-20662 Naked>                              Σ-4        ↓ →0x20682 ←0x20620 ←0x20654 ←0x20662
            <MI 2065c  CMP.W   (A7+0x2),D7>                                     {[-4-]}
            <MI 20660  BHI     0x20682>                                         {[-4-]}
        <POP 20662-20682 Naked>                              Σ-4        ↓ →0x2065c
            <MI 20662  MOVEA.L 0x25474,A0>                                      {[-4-]}
            <MI 20664  CLR.L   D0>                                              {[-4-]}
            <MI 20666  MOVE.W  D7,D0>                                           {[-4-]}
            <MI 20668  ROR.L   #0x2,D0>                                         {[-4-]}
            <MI 2066a  ADDA.W  D0,A0>                                           {[-4-]}
            <MI 2066c  SWAP.W  D0>                                              {[-4-]}
            <MI 2066e  ROL.W   #0x3,D0>                                         {[-4-]}
            <MI 20670  MOVEQ.L #0x40,D1>                                        {[-4-]}
            <MI 20672  MOVE.W  #0xff3f,D2>                                      {[-4-]}
            <MI 20676  ROR.W   D0,D2>                                           {[-4-]}
            <MI 20678  AND.B   D2,(A0)>                                         {[-4-]}
            <MI 2067a  LSR.B   D0,D1>                                           {[-4-]}
            <MI 2067c  OR.B    D1,(A0)>                                         {[-4-]}
            <MI 2067e  ADDQ.W  #0x1,D7>                                         {[-4-]}
            <MI 20680  BCC     0x2065c>                                         {[-4-]}
        <POP 20682-2068e Naked>                              Σ-4 Δ+4    ↓ →0x20620 ←0x2065c
            <POP 20682-20684 StackAdj>                       Δ+4                {}
            <MI 20684  ADDQ.L  #0x1,D6>                                         {}
            <MI 20686  CMPI.L  #0x00000007,D6>                                  {}
            <MI 2068c  BLE     0x20620>                                         {}
        <POP 2068e-206b0 Naked>                              Σ0         ↓ →0x206e6
            <Const 0x2068e 0x2.2>                            Δ-2                {[#2]}
            <Const 0x20692 0x2.2>                            Δ-2                {[#2]|[#2]}
            <Const 0x20696 0x1.4>                            Δ-4                {[#2]|[#2]|[##1]}
            <MI 2069a  LEA.L   (A6-0x404),A0>                                   {[#2]|[#2]|[##1]}
            <MI 2069e  MOVE.L  A0,-(A7)>                     Δ-4                {[#2]|[#2]|[##1]|[4, 'A0']}
            <Const 0x206a0 0x264bc.4>                        Δ-4                {[#2]|[#2]|[##1]|[4, 'A0']|[##156860]}
            <Call 0x206a2 0x1036c>                                              {[#2]|[#2]|[##1]|[4, 'A0']|[##156860]}
                RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
            <POP 206a8-206ac StackAdj>                       Δ+16               {}
            <MI 206ac  TST.B   0x264bc>                                         {}
            <MI 206ae  BNE     0x206e6>                                         {}
        <POP 206b0-206e6 Naked>                              Σ0         ↓
            <Blob 0x206b0 [44] @>                            Δ-44               {[«44""»]}
            <Const 0x206c2 0xe.2>                            Δ-2                {[«44""»]|[#14]}
            <POP 206c6-206c8 StackAdj>                       Δ-4                {[«44""»]|[#14]|[-4-]}
            <Lit 0x206c8 43>                                                    {[«44""»]|[#14]|[$$Can't read volume label due to disk errors.]}
            <Call 0x206dc 0x103b8>                                              {[«44""»]|[#14]|[$$Can't read volume label due to disk errors.]}
                PopProgram(status : Byte; msg : String)
            <POP 206e2-206e6 StackAdj>                       Δ+50               {}
        <POP 206e6-2074c Naked>                              Σ0         ↓ ←0x2068e
            <MI 206e6  MOVE.W  0x1000c,D0>                                      {}
            <MI 206ec  MULU.W  (A6-0x3e8),D0>                                   {}
            <MI 206f0  CLR.L   D1>                                              {}
            <MI 206f2  MOVE.B  (A6-0x3e6),D1>                                   {}
            <MI 206f6  MULU.W  0x1000a,D1>                                      {}
            <MI 206fc  ADD.L   D0,D1>                                           {}
            <MI 206fe  CLR.L   D0>                                              {}
            <MI 20700  MOVE.B  (A6-0x3e5),D0>                                   {}
            <MI 20704  ADDQ.W  #0x1,D0>                                         {}
            <MI 20706  ASR.W   #0x1,D0>                                         {}
            <MI 20708  EXTW.L  D0>                                              {}
            <MI 2070a  ADD.L   D1,D0>                                           {}
            <POP 0x2070c LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 20712  MOVE.W  D0,(A6-0x4)>                                     {}
            <MI 20716  MOVE.W  0x1000c,D0>                                      {}
            <MI 2071c  MULU.W  (A6-0x3e4),D0>                                   {}
            <MI 20720  CLR.L   D1>                                              {}
            <MI 20722  MOVE.B  (A6-0x3e2),D1>                                   {}
            <MI 20726  MULU.W  0x1000a,D1>                                      {}
            <MI 2072c  ADD.L   D0,D1>                                           {}
            <MI 2072e  CLR.L   D0>                                              {}
            <MI 20730  MOVE.B  (A6-0x3e1),D0>                                   {}
            <MI 20734  SUBQ.W  #0x1,D0>                                         {}
            <MI 20736  EXTW.L  D0>                                              {}
            <MI 20738  DIVS.W  #0x2,D0>                                         {}
            <MI 2073c  EXTW.L  D0>                                              {}
            <MI 2073e  ADD.L   D1,D0>                                           {}
            <POP 0x20740 LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 20746  MOVE.W  D0,(A6-0x2)>                                     {}
            <MI 2074a  MOVEQ.L #0x01,D7>                                        {}
        <POP 2074c-20752 Naked>                              Σ0         ↓ →0x2077c ←0x20752
            <MI 2074c  CMP.W   (A6-0x4),D7>                                     {}
            <MI 20750  BCC     0x2077c>                                         {}
        <POP 20752-2077c Naked>                              Σ0         →0x2074c
            <MI 20752  MOVEA.L 0x25474,A0>                                      {}
            <MI 20754  CLR.L   D0>                                              {}
            <MI 20756  MOVE.W  D7,D0>                                           {}
            <MI 20758  MOVE.L  D0,D1>                                           {}
            <MI 2075a  ROR.L   #0x2,D1>                                         {}
            <MI 2075c  ADDA.W  D1,A0>                                           {}
            <MI 2075e  SWAP.W  D1>                                              {}
            <MI 20760  ROL.W   #0x3,D1>                                         {}
            <MI 20762  MOVEQ.L #0x40,D2>                                        {}
            <MI 20764  MOVE.W  #0xff3f,D3>                                      {}
            <MI 20768  ROR.W   D1,D3>                                           {}
            <MI 2076a  AND.B   D3,(A0)>                                         {}
            <MI 2076c  LSR.B   D1,D2>                                           {}
            <MI 2076e  OR.B    D2,(A0)>                                         {}
            <MI 20770  ADDQ.L  #0x1,D0>                                         {}
            <POP 0x20772 LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 20778  MOVE.W  D0,D7>                                           {}
            <MI 2077a  BRA     0x2074c>                                         {}
        <POP 2077c-2077e Naked>                              Σ0         ↓ ←0x2074c
            <MI 2077c  MOVE.W  #0xffff,D7>                                      {}
        <POP 2077e-20784 Naked>                              Σ0         ↓ →0x207ae ←0x20784
            <MI 2077e  CMP.W   (A6-0x2),D7>                                     {}
            <MI 20782  BLS     0x207ae>                                         {}
        <POP 20784-207ae Naked>                              Σ0         →0x2077e
            <MI 20784  MOVEA.L 0x25474,A0>                                      {}
            <MI 20786  CLR.L   D0>                                              {}
            <MI 20788  MOVE.W  D7,D0>                                           {}
            <MI 2078a  MOVE.L  D0,D1>                                           {}
            <MI 2078c  ROR.L   #0x2,D1>                                         {}
            <MI 2078e  ADDA.W  D1,A0>                                           {}
            <MI 20790  SWAP.W  D1>                                              {}
            <MI 20792  ROL.W   #0x3,D1>                                         {}
            <MI 20794  MOVEQ.L #0x40,D2>                                        {}
            <MI 20796  MOVE.W  #0xff3f,D3>                                      {}
            <MI 2079a  ROR.W   D1,D3>                                           {}
            <MI 2079c  AND.B   D3,(A0)>                                         {}
            <MI 2079e  LSR.B   D1,D2>                                           {}
            <MI 207a0  OR.B    D2,(A0)>                                         {}
            <MI 207a2  SUBQ.L  #0x1,D0>                                         {}
            <POP 0x207a4 LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 207aa  MOVE.W  D0,D7>                                           {}
            <MI 207ac  BRA     0x2077e>                                         {}
        <POP 207ae-207b6 Epilogue>                           Σ0         ←0x2077e

0x207b6


@ 207b6
        <LVAR  0x010 2(r)>
        <LVAR  0x00e 2(r)>
        <LVAR  0x00c 2(r)>
        <LVAR  0x008 4(r)>
    <POP 207b6-20906 Body>                                              
        <POP 207b6-207cc Prologue>                           Σ0         ↓
        <POP 207cc-207dc RegCacheLoad>                       Σ0         ↓
        <POP 207dc-207e6 Naked>                              Σ0         ↓
            <MI 207dc  MOVEA.L (A6+0x8),A0>                                     {}
            <MI 207e0  CLR.B   (A0)>                                            {}
            <MI 207e2  MOVE.W  (A6+0xe),D7>                                     {}
        <POP 207e6-20802 Naked>                              Σ0         ↓ →0x208fe ←0x208ec
            <MI 207e6  MOVEA.L (A6+0x8),A0>                                     {}
            <MI 207ea  CLR.L   D0>                                              {}
            <MI 207ec  MOVE.W  (A6+0xe),D0>                                     {}
            <MI 207f0  CLR.L   D1>                                              {}
            <MI 207f2  MOVE.W  (A6+0xc),D1>                                     {}
            <MI 207f6  ADD.L   D0,D1>                                           {}
            <MI 207f8  CLR.L   D0>                                              {}
            <MI 207fa  MOVE.W  D7,D0>                                           {}
            <MI 207fc  CMP.L   D1,D0>                                           {}
            <MI 207fe  BCC     0x208fe>                                         {}
        <POP 20802-20808 Naked>                              Σ0         ↓ →0x208fe
            <MI 20802  TST.B   (A0)>                                            {}
            <MI 20804  BNE     0x208fe>                                         {}
        <POP 20808-2081c Naked>                              Σ0         ↓ →0x20836
            <MI 20808  MOVEA.L 0x25474,A1>                                      {}
            <MI 2080a  MOVE.L  D0,D1>                                           {}
            <MI 2080c  ROR.L   #0x2,D1>                                         {}
            <MI 2080e  ADDA.W  D1,A1>                                           {}
            <MI 20810  SWAP.W  D1>                                              {}
            <MI 20812  ROL.W   #0x3,D1>                                         {}
            <MI 20814  MOVE.B  (A1),D2>                                         {}
            <MI 20816  LSL.B   D1,D2>                                           {}
            <MI 20818  LSR.B   #0x6,D2>                                         {}
            <MI 2081a  BNE     0x20836>                                         {}
        <POP 2081c-20836 Naked>                              Σ0         →0x208ec
            <MI 2081c  MOVE.W  (A6+0x10),D2>                                    {}
            <MI 20820  MOVE.W  #0xff3f,D3>                                      {}
            <MI 20824  ROR.W   D1,D3>                                           {}
            <MI 20826  AND.B   D3,(A1)>                                         {}
            <MI 20828  ANDI.B  #0x03,D2>                                        {}
            <MI 2082c  LSL.B   #0x6,D2>                                         {}
            <MI 2082e  LSR.B   D1,D2>                                           {}
            <MI 20830  OR.B    D2,(A1)>                                         {}
            <MI 20832  BRA     0x208ec>                                         {}
        <POP 20836-208ec Naked>                              Σ0         ↓ ←0x20808
            <MI 20836  MOVEQ.L #0x14,D1>                                        {}
            <MI 20838  MULS.W  (A6+0x10),D1>                                    {}
            <MI 2083c  LEA.L   0x20430,A1>                                      {}
            <Blob 0x20840 [20] (A1+D1.W)>                    Δ-20               {[«20»]}
            <Blob 0x20850 [34] @>                            Δ-34               {[«20»]|[«34""»]}
            <MI 20862  MOVEA.L 0x25474,A1>                                      {[«20»]|[«34""»]}
            <MI 20864  MOVE.L  D0,D1>                                           {[«20»]|[«34""»]}
            <MI 20866  ROR.L   #0x2,D1>                                         {[«20»]|[«34""»]}
            <MI 20868  ADDA.W  D1,A1>                                           {[«20»]|[«34""»]}
            <MI 2086a  SWAP.W  D1>                                              {[«20»]|[«34""»]}
            <MI 2086c  ROL.W   #0x3,D1>                                         {[«20»]|[«34""»]}
            <MI 2086e  CLR.L   D2>                                              {[«20»]|[«34""»]}
            <MI 20870  MOVE.B  (A1),D2>                                         {[«20»]|[«34""»]}
            <MI 20872  LSL.B   D1,D2>                                           {[«20»]|[«34""»]}
            <MI 20874  LSR.B   #0x6,D2>                                         {[«20»]|[«34""»]}
            <MI 20876  MULU.W  #0x14,D2>                                        {[«20»]|[«34""»]}
            <MI 20878  CLR.L   D1>                                              {[«20»]|[«34""»]}
            <MI 2087a  MOVE.W  D2,D1>                                           {[«20»]|[«34""»]}
            <MI 2087c  LEA.L   0x20430,A1>                                      {[«20»]|[«34""»]}
            <Blob 0x20880 [20] (A1+D1.L)>                    Δ-20               {[«20»]|[«34""»]|[«20»]}
            <Blob 0x20890 [8] @>                             Δ-8                {[«20»]|[«34""»]|[«20»]|[«8""»]}
            <POP 208a0-208a2 StackAdj>                       Δ-8                {[«20»]|[«34""»]|[«20»]|[«8""»]|[-8-]}
            <Lit 0x208a2>                                                       {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]}
                <Pointer.sp 0x208a2 70>                      Δ-4        
                <Const 0x208a6 0x1.2>                        Δ-2        
                <Const 0x208a8 0x14.2>                       Δ-2        
                <Call 0x208aa 0x102c4>
                    StringLit(Src : Pointer; Offset: W; Len : W) : String
                <POP 208ac-208ae StackAdj>                   Δ+8        
            <POP 208ac-208ae StackAdj>                       Δ-4                {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]|[-4-]}
            <Lit 0x208ae 33>                                                    {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]|[$$ block is already allocated to a_]}
            <POP 208ba-208bc StackAdj>                       Δ-4                {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]|[$$ block is already allocated to a_]|[-4-]}
            <Lit 0x208bc>                                                       {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]|[$$ block is already allocated to a_]|[$$…]}
                <Pointer.sp 0x208bc 24>                      Δ-4        
                <Const 0x208c0 0x1.2>                        Δ-2        
                <Const 0x208c2 0x14.2>                       Δ-2        
                <Call 0x208c4 0x102c4>
                    StringLit(Src : Pointer; Offset: W; Len : W) : String
                <POP 208c6-208c8 StackAdj>                   Δ+8        
            <POP 208c6-208c8 StackAdj>                       Δ-4                {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]|[$$ block is already allocated to a_]|[$$…]|[-4-]}
            <Lit 0x208c8 7>                                                     {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]|[$$ block is already allocated to a_]|[$$…]|[$$ block!]}
            <Call 0x208d6 0x102d8>                                              {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]|[$$…]|[$$ block is already allocated to a_]|[$$…]|[$$ block!]}
                StringCat4(a, b, c, d : String) : String
            <POP 208dc-208e0 StackAdj>                       Δ+16               {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]}
            <Call 0x208e0 0x103e0>                                              {[«20»]|[«34""»]|[«20»]|[«8""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 208e6-208ea StackAdj>                       Δ+86               {}
            <MI 208ea  MOVE.B  #0x01,(A0)>                                      {}
        <POP 208ec-208fe Naked>                              Σ0         →0x207e6 ←0x2081c
            <MI 208ec  ADDQ.L  #0x1,D0>                                         {}
            <POP 0x208ee LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 208f8  MOVE.W  D0,D7>                                           {}
            <MI 208fa  BRA     0x207e6>                                         {}
        <POP 208fe-20906 Epilogue>                           Σ0         ←0x207e6 ←0x20802

0x20906


@ 20906
        <LVAR  0x010 4(r)>
        <LVAR  0x00c 4(r)>
        <LVAR  0x008 4(r)>
        <LVAR -0x003 @ 1(r)>
        <LVAR -0x004 @ 1(r)>
        <LVAR -0x408 2(r)>
        <LVAR -0x40a @ 2(r)>
    <POP 20906-20a78 Body>                                              
        <POP 20906-2091c Prologue>                           Σ0         ↓
        <POP 2091c-2092c RegCacheLoad>                       Σ0         ↓
        <POP 2092c-20970 Naked>                              Σ0         ↓
            <Blob 0x2092c [18] @>                            Δ-18               {[«18""»]}
            <POP 20938-2093a StackAdj>                       Δ-4                {[«18""»]|[-4-]}
            <Lit 0x2093a 18>                                                    {[«18""»]|[$$Loading free list.]}
            <Call 0x20948 0x103e0>                                              {[«18""»]|[$$Loading free list.]}
                WriteConsoleStringCrLf(str : String)
            <POP 2094e-20952 StackAdj>                       Δ+22               {}
            <MI 20952  MOVEA.L (A6+0xc),A0>                                     {}
            <MI 20956  CLR.W   (A0)>                                            {}
            <MI 20958  MOVEA.L (A6+0x10),A0>                                    {}
            <MI 2095c  CLR.W   (A0)>                                            {}
            <MI 2095e  MOVEA.L (A6+0x8),A0>                                     {}
            <MI 20962  CLR.W   (A0)>                                            {}
            <MI 20964  LEA.L   (A6-0x40a),A0>                                   {}
            <MI 20966  MOVE.L  A0,-(A7)>                     Δ-4                {[4, 'A0']}
            <MI 20968  MOVEA.L (A7)+,A4>                     Δ+4                {}
            <MI 2096a  MOVE.W  0x10010,D7>                                      {}
        <POP 20970-20976 Naked>                              Σ0         ↓ →0x20a70 ←0x20a68
            <MI 20970  TST.W   D7>                                              {}
            <MI 20972  BEQ     0x20a70>                                         {}
        <POP 20976-209ac Naked>                              Σ0         ↓ →0x209d8
            <MI 20976  MOVEA.L (A6+0xc),A0>                                     {}
            <MI 2097a  CLR.L   D0>                                              {}
            <MI 2097c  MOVE.W  (A0),D0>                                         {}
            <MI 2097e  ADDQ.L  #0x1,D0>                                         {}
            <POP 0x20980 LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 2098a  MOVE.W  D0,(A0)>                                         {}
            <Const 0x2098c 0x2.2>                            Δ-2                {[#2]}
            <MI 20990  MOVE.W  D7,-(A7)>                     Δ-2                {[#2]|[2, 'D7']}
            <Const 0x20992 0x1.4>                            Δ-4                {[#2]|[2, 'D7']|[##1]}
            <MI 20996  MOVE.L  A4,-(A7)>                     Δ-4                {[#2]|[2, 'D7']|[##1]|[4, 'A4']}
            <Pointer.fp 0x20998 <LVAR -0x004 @ 1(r)>>        Δ-4                {[#2]|[2, 'D7']|[##1]|[4, 'A4']|[@@-4]}
            <Call 0x2099c 0x1036c>                                              {[#2]|[2, 'D7']|[##1]|[4, 'A4']|[@@-4]}
                RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
            <POP 209a2-209a6 StackAdj>                       Δ+16               {}
            <MI 209a6  TST.B   (A6-0x4)>                                        {}
            <MI 209aa  BNE     0x209d8>                                         {}
        <POP 209ac-209d8 Naked>                              Σ0         ↓
            <Blob 0x209ac [30] @>                            Δ-30               {[«30""»]}
            <Const 0x209be 0xe.2>                            Δ-2                {[«30""»]|[#14]}
            <POP 209c0-209c2 StackAdj>                       Δ-4                {[«30""»]|[#14]|[-4-]}
            <Lit 0x209c2 29>                                                    {[«30""»]|[#14]|[$$Disk error on free list read!]}
            <Call 0x209d0 0x103b8>                                              {[«30""»]|[#14]|[$$Disk error on free list read!]}
                PopProgram(status : Byte; msg : String)
            <POP 209d6-209d8 StackAdj>                       Δ+36               {}
        <POP 209d8-209dc Naked>                              Σ0         ↓ →0x20a04 ←0x20976
            <MI 209d8  TST.W   (A6-0x40a)>                                      {}
            <MI 209da  BNE     0x20a04>                                         {}
        <POP 209dc-20a04 Naked>                              Σ0         ↓
            <Blob 0x209dc [32] @>                            Δ-32               {[«32""»]}
            <Const 0x209e8 0xe.2>                            Δ-2                {[«32""»]|[#14]}
            <POP 209ea-209ec StackAdj>                       Δ-4                {[«32""»]|[#14]|[-4-]}
            <Lit 0x209ec 32>                                                    {[«32""»]|[#14]|[$$Zero length extent on free list!]}
            <Call 0x209fa 0x103b8>                                              {[«32""»]|[#14]|[$$Zero length extent on free list!]}
                PopProgram(status : Byte; msg : String)
            <POP 20a00-20a04 StackAdj>                       Δ+38               {}
        <POP 20a04-20a26 Naked>                              Σ0         ↓ →0x20a28 ←0x209d8
            <MI 20a04  MOVEA.L (A6+0x10),A0>                                    {}
            <MI 20a08  CLR.L   D0>                                              {}
            <MI 20a0a  MOVE.W  (A0),D0>                                         {}
            <MI 20a0c  CLR.L   D1>                                              {}
            <MI 20a0e  MOVE.W  (A6-0x40a),D1>                                   {}
            <MI 20a10  ADD.L   D1,D0>                                           {}
            <POP 0x20a12 LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 20a1c  MOVE.W  D0,(A0)>                                         {}
            <MI 20a1e  MOVEA.L (A6+0x8),A0>                                     {}
            <MI 20a22  CMP.W   (A0),D1>                                         {}
            <MI 20a24  BLS     0x20a28>                                         {}
        <POP 20a26-20a28 Naked>                              Σ0         ↓
            <MI 20a26  MOVE.W  D1,(A0)>                                         {}
        <POP 20a28-20a42 Naked>                              Σ0         ↓ →0x20a68 ←0x20a04
            <Const 0x20a28 0x3.2>                            Δ-2                {[#3]}
            <MI 20a2c  MOVE.W  D7,-(A7)>                     Δ-2                {[#3]|[2, 'D7']}
            <MI 20a2e  MOVE.W  (A6-0x40a),-(A7)>             Δ-2                {[#3]|[2, 'D7']|[2, '(A6-0x40a)']}
            <Pointer.fp 0x20a30 <LVAR -0x003 @ 1(r)>>        Δ-4                {[#3]|[2, 'D7']|[2, '(A6-0x40a)']|[@@-3]}
            <Call 0x20a34 0x207b6>                                              {[#3]|[2, 'D7']|[2, '(A6-0x40a)']|[@@-3]}
            <POP 20a38-20a3c StackAdj>                       Δ+10               {}
            <MI 20a3c  TST.B   (A6-0x3)>                                        {}
            <MI 20a40  BEQ     0x20a68>                                         {}
        <POP 20a42-20a68 Naked>                              Σ0         →0x20a70
            <Blob 0x20a42 [36] @>                            Δ-36               {[«36""»]}
            <POP 20a4e-20a50 StackAdj>                       Δ-4                {[«36""»]|[-4-]}
            <Lit 0x20a50 36>                                                    {[«36""»]|[$$Remainder of list will not be loaded]}
            <Call 0x20a5c 0x103e0>                                              {[«36""»]|[$$Remainder of list will not be loaded]}
                WriteConsoleStringCrLf(str : String)
            <POP 20a62-20a66 StackAdj>                       Δ+40               {}
            <MI 20a66  BRA     0x20a70>                                         {}
        <POP 20a68-20a70 Naked>                              Σ0         →0x20970 ←0x20a28
            <MI 20a68  MOVE.W  (A6-0x408),D7>                                   {}
            <MI 20a6c  BRA     0x20970>                                         {}
        <POP 20a70-20a78 Epilogue>                           Σ0         ←0x20970 ←0x20a42

0x20a78


@ 20a78
        <LVAR  0x008 4(r)>
        <LVAR -0x004 4(rw)>
        <LVAR -0x00b @ 1(r)>
        <LVAR -0x00c @ 1(r)>
        <LVAR -0x010 4(rw)>
        <LVAR -0x020 4(w)>
    <POP 20a78-20d4c Body>                                   Δ-12       
        <POP 20a78-20a8e Prologue>                           Σ0         ↓
        <POP 20a8e-20a9e RegCacheLoad>                       Σ0         ↓
        <POP 20a9e-20ad4 Naked>                              Σ0         ↓
            <Blob 0x20a9e [20] @>                            Δ-20               {[«20""»]}
            <POP 20ab0-20ab2 StackAdj>                       Δ-4                {[«20""»]|[-4-]}
            <Lit 0x20ab2 19>                                                    {[«20""»]|[$$Scanning directory.]}
            <Call 0x20ac2 0x103e0>                                              {[«20""»]|[$$Scanning directory.]}
                WriteConsoleStringCrLf(str : String)
            <POP 20ac4-20ac8 StackAdj>                       Δ+24               {}
            <MI 20ac8  MOVEA.L (A6+0x8),A0>                                     {}
            <MI 20acc  CLR.L   (A0)>                                            {}
            <MI 20ace  CLR.L   (A6-0x4)>                                        {}
            <MI 20ad2  MOVEQ.L #0x00,D0>                                        {}
        <POP 20ad4-20b48 Naked>                              Σ0 Δ-4     ↓ →0x20b7a ←0x20d3c
            <MI 20ad4  MOVE.L  D0,-(A7)>                     Δ-4                {[4, 'D0']}
            <MI 20ad6  MOVE.L  D0,D1>                                           {[4, 'D0']}
            <MI 20ad8  ASL.L   #0x2,D1>                                         {[4, 'D0']}
            <MI 20ada  MOVE.L  D1,D4>                                           {[4, 'D0']}
            <MI 20adc  MOVE.L  #0x100,D3>                                       {[4, 'D0']}
            <Call 0x20ae2 0x10294>                                              {[4, 'D0']}
                ?divs_d3_d4
            <MI 20ae8  MOVE.L  D3,-(A7)>                     Δ-4                {[4, 'D0']|[4, 'D3']}
            <MI 20aea  MOVE.L  D0,D4>                                           {[4, 'D0']|[4, 'D3']}
            <MI 20aec  MOVEQ.L #0x40,D3>                                        {[4, 'D0']|[4, 'D3']}
            <Call 0x20aee 0x10294>                                              {[4, 'D0']|[4, 'D3']}
                ?divs_d3_d4
            <POP 0x20af4 LimitCheck 0x0 ≤ D4 ≤ 0x7>                             {[4, 'D0']|[4, 'D3']}
            <MI 20afe  ASL.L   #0x1,D4>                                         {[4, 'D0']|[4, 'D3']}
            <MI 20b00  LEA.L   0x0,A0>                                          {[4, 'D0']|[4, 'D3']}
            <MI 20b04  LEA.L   (A0+D4.L),A0>                                    {[4, 'D0']|[4, 'D3']}
            <MI 20b08  ADDA.L  #0x10012,A0>                                     {[4, 'D0']|[4, 'D3']}
            <MI 20b0e  CLR.L   D1>                                              {[4, 'D0']|[4, 'D3']}
            <MI 20b10  MOVE.W  (A0),D1>                                         {[4, 'D0']|[4, 'D3']}
            <MI 20b12  MOVE.L  (A7)+,D2>                     Δ+4                {[4, 'D0']}
            <MI 20b14  ADD.L   D1,D2>                                           {[4, 'D0']}
            <MI 20b16  MOVE.L  D2,(A6-0x20)>                                    {[4, 'D0']}
            <Const 0x20b1a 0x2.2>                            Δ-2                {[4, 'D0']|[#2]}
            <POP 0x20b1e LimitCheck 0x0 ≤ D2 ≤ 0xffff>                          {[4, 'D0']|[#2]}
            <MI 20b28  MOVE.W  D2,-(A7)>                     Δ-2                {[4, 'D0']|[#2]|[2, 'D2']}
            <Const 0x20b2a 0x4.4>                            Δ-4                {[4, 'D0']|[#2]|[2, 'D2']|[##4]}
            <Blob 0x20b2e [4] 0x264be>                       Δ-4                {[4, 'D0']|[#2]|[2, 'D2']|[##4]|[«4»]}
            <Pointer.fp 0x20b34 <LVAR -0x00c @ 1(r)>>        Δ-4                {[4, 'D0']|[#2]|[2, 'D2']|[##4]|[«4»]|[@@-12]}
            <Call 0x20b38 0x1036c>                                              {[4, 'D0']|[#2]|[2, 'D2']|[##4]|[«4»]|[@@-12]}
                RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
            <POP 20b3e-20b42 StackAdj>                       Δ+16               {[4, 'D0']}
            <MI 20b42  TST.B   (A6-0xc)>                                        {[4, 'D0']}
            <MI 20b46  BNE     0x20b7a>                                         {[4, 'D0']}
        <POP 20b48-20b7a Naked>                              Σ-4        ↓
            <Blob 0x20b48 [22] @>                            Δ-22               {[-4-]|[«22""»]}
            <Const 0x20b5a 0xe.2>                            Δ-2                {[-4-]|[«22""»]|[#14]}
            <POP 20b5e-20b60 StackAdj>                       Δ-4                {[-4-]|[«22""»]|[#14]|[-4-]}
            <Lit 0x20b60 21>                                                    {[-4-]|[«22""»]|[#14]|[$$Directory read error!]}
            <Call 0x20b70 0x103b8>                                              {[-4-]|[«22""»]|[#14]|[$$Directory read error!]}
                PopProgram(status : Byte; msg : String)
            <POP 20b76-20b7a StackAdj>                       Δ+28               {[-4-]}
        <POP 20b7a-20b7c Naked>                              Σ-4        ↓ ←0x20ad4
            <MI 20b7a  MOVEQ.L #0x00,D1>                                        {[-4-]}
        <POP 20b7c-20b82 Naked>                              Σ-4 Δ-4    ↓ ←0x20d28
            <MI 20b7c  MOVE.L  D1,-(A7)>                     Δ-4                {[-4-]|[4, 'D1']}
            <MI 20b7e  CLR.L   (A6-0x10)>                                       {[-4-]|[4, 'D1']}
            <MI 20b80  MOVEQ.L #0x00,D5>                                        {[-4-]|[4, 'D1']}
        <POP 20b82-20bb6 Naked>                              Σ-8 Δ-4    ↓ →0x20ce2 ←0x20cd8
            <MI 20b82  MOVE.L  (A7),D0>                                         {[-8-]}
            <POP 0x20b84 LimitCheck 0x0 ≤ D0 ≤ 0x3>                             {[-8-]}
            <MI 20b8e  ASL.L   #0x8,D0>                                         {[-8-]}
            <MI 20b90  ASL.L   #0x2,D0>                                         {[-8-]}
            <MI 20b92  LEA.L   0x2146c,A0>                                      {[-8-]}
            <POP 0x20b98 LimitCheck 0x0 ≤ D5 ≤ 0xf>                             {[-8-]}
            <MI 20ba2  MOVE.L  D5,D1>                                           {[-8-]}
            <MI 20ba4  ASL.L   #0x6,D1>                                         {[-8-]}
            <MI 20ba6  LEA.L   (A0+D0.L),A0>                                    {[-8-]}
            <MI 20baa  MOVE.L  A0,-(A7)>                     Δ-4                {[-8-]|[4, 'A0']}
            <MI 20bac  CMPI.L  #0x00000010,D5>                                  {[-8-]|[4, 'A0']}
            <MI 20bb2  BGE     0x20ce2>                                         {[-8-]|[4, 'A0']}
        <POP 20bb6-20bc6 Naked>                              Σ-12       ↓ →0x20ce2
            <MI 20bb6  LEA.L   (A0+D1.L),A0>                                    {[-12-]}
            <MI 20bba  MOVE.B  (A0+0x404b),D0>                                  {[-12-]}
            <MI 20bbe  LSL.B   #0x4,D0>                                         {[-12-]}
            <MI 20bc0  LSR.B   #0x7,D0>                                         {[-12-]}
            <MI 20bc2  BNE     0x20ce2>                                         {[-12-]}
        <POP 20bc6-20bd6 Naked>                              Σ-12 Δ-4   ↓
            <MI 20bc6  ADDQ.L  #0x1,(A6-0x10)>                                  {[-12-]}
            <MI 20bc8  MOVEA.L (A7),A0>                                         {[-12-]}
            <MI 20bca  LEA.L   (A0+D1.L),A0>                                    {[-12-]}
            <MI 20bce  MOVE.L  A0,-(A7)>                     Δ-4                {[-12-]|[4, 'A0']}
            <MI 20bd0  MOVEQ.L #0x00,D7>                                        {[-12-]|[4, 'A0']}
            <MI 20bd2  MOVEQ.L #0x00,D6>                                        {[-12-]|[4, 'A0']}
            <MI 20bd4  MOVEQ.L #0x00,D0>                                        {[-12-]|[4, 'A0']}
        <POP 20bd6-20bf0 Naked>                              Σ-16       ↓ →0x20c26 ←0x20c26
            <POP 0x20bd6 LimitCheck 0x0 ≤ D0 ≤ 0x5>                             {[-16-]}
            <MI 20be0  MOVE.L  D0,D1>                                           {[-16-]}
            <MI 20be2  ASL.L   #0x2,D1>                                         {[-16-]}
            <MI 20be4  MOVEA.L (A7),A0>                                         {[-16-]}
            <MI 20be6  LEA.L   (A0+0x400c),A0>                                  {[-16-]}
            <MI 20bea  TST.W   (A0+D1.L+#0x22)>                                 {[-16-]}
            <MI 20bee  BEQ     0x20c26>                                         {[-16-]}
        <POP 20bf0-20c24 Naked>                              Σ-16       ↓ →0x20c26
            <Const 0x20bf0 0x2.2>                            Δ-2                {[-16-]|[#2]}
            <MI 20bf4  MOVE.W  (A0+D1.L+#0x24),-(A7)>        Δ-2                {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']}
            <MI 20bf8  MOVE.W  (A0+D1.L+#0x22),D2>                              {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']}
            <MI 20bfc  EXTW.L  D2>                                              {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']}
            <MI 20bfe  SUB.L   D7,D2>                                           {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']}
            <POP 0x20c00 LimitCheck 0x0 ≤ D2 ≤ 0xffff>                          {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']}
            <MI 20c0a  MOVE.W  D2,-(A7)>                     Δ-2                {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']|[2, 'D2']}
            <Pointer.fp 0x20c0c <LVAR -0x00b @ 1(r)>>        Δ-4                {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']|[2, 'D2']|[@@-11]}
            <Call 0x20c10 0x207b6>                                              {[-16-]|[#2]|[2, '(A0+D1.L+#0x24)']|[2, 'D2']|[@@-11]}
            <POP 20c14-20c18 StackAdj>                       Δ+10               {[-16-]}
            <MI 20c18  MOVE.W  (A0+D1.L+#0x22),D2>                              {[-16-]}
            <MI 20c1c  EXTW.L  D2>                                              {[-16-]}
            <MI 20c1e  MOVE.L  D2,D7>                                           {[-16-]}
            <MI 20c20  TST.L   D0>                                              {[-16-]}
            <MI 20c22  BLE     0x20c26>                                         {[-16-]}
        <POP 20c24-20c26 Naked>                              Σ-16       ↓
            <MI 20c24  MOVEQ.L #0x01,D6>                                        {[-16-]}
        <POP 20c26-20c30 Naked>                              Σ-16       ↓ →0x20bd6 ←0x20bd6 ←0x20bf0
            <MI 20c26  ADDQ.L  #0x1,D0>                                         {[-16-]}
            <MI 20c28  CMPI.L  #0x00000005,D0>                                  {[-16-]}
            <MI 20c2e  BLE     0x20bd6>                                         {[-16-]}
        <POP 20c30-20c34 Naked>                              Σ-16       ↓ →0x20c86
            <MI 20c30  TST.B   D6>                                              {[-16-]}
            <MI 20c32  BEQ     0x20c86>                                         {[-16-]}
        <POP 20c34-20c86 Naked>                              Σ-16       ↓
            <Blob 0x20c34 [26] @>                            Δ-26               {[-16-]|[«26""»]}
            <MI 20c46  MOVEA.L (A7+0x1a),A0>                                    {[-16-]|[«26""»]}
            <Blob 0x20c4a [30] (A0+0x402a)>                  Δ-30               {[-16-]|[«26""»]|[«30»]}
            <POP 20c56-20c58 StackAdj>                       Δ-8                {[-16-]|[«26""»]|[«30»]|[-8-]}
            <Lit 0x20c58 25>                                                    {[-16-]|[«26""»]|[«30»]|[-4-]|[$$File is non-contiguous :_]}
            <POP 20c66-20c68 StackAdj>                       Δ-4                {[-16-]|[«26""»]|[«30»]|[-4-]|[$$File is non-contiguous :_]|[-4-]}
            <Lit 0x20c68>                                                       {[-16-]|[«26""»]|[«30»]|[-4-]|[$$File is non-contiguous :_]|[$$…]}
                <Pointer.sp 0x20c68 12>                      Δ-4        
                <Const 0x20c6c 0x1.2>                        Δ-2        
                <Const 0x20c70 0x1e.2>                       Δ-2        
                <Call 0x20c74 0x102c4>
                    StringLit(Src : Pointer; Offset: W; Len : W) : String
                <POP 20c76-20c78 StackAdj>                   Δ+8        
            <Call 0x20c78 0x102d0>                                              {[-16-]|[«26""»]|[«30»]|[-4-]|[$$File is non-contiguous :_]|[$$…]}
                StringCat2(a, b : String) : String
            <POP 20c7e-20c80 StackAdj>                       Δ+8                {[-16-]|[«26""»]|[«30»]|[-4-]}
            <Call 0x20c80 0x103e0>                                              {[-16-]|[«26""»]|[«30»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 20c82-20c86 StackAdj>                       Δ+60               {[-16-]}
        <POP 20c86-20c8c Naked>                              Σ-16       ↓ →0x20cd8 ←0x20c30
            <MI 20c86  TST.B   (A6-0xb)>                                        {[-16-]}
            <MI 20c8a  BEQ     0x20cd8>                                         {[-16-]}
        <POP 20c8c-20cd8 Naked>                              Σ-16       ↓
            <Blob 0x20c8c [24] @>                            Δ-24               {[-16-]|[«24""»]}
            <MI 20c98  MOVEA.L (A7+0x18),A0>                                    {[-16-]|[«24""»]}
            <Blob 0x20c9c [30] (A0+0x402a)>                  Δ-30               {[-16-]|[«24""»]|[«30»]}
            <POP 20ca8-20caa StackAdj>                       Δ-8                {[-16-]|[«24""»]|[«30»]|[-8-]}
            <Lit 0x20caa 24>                                                    {[-16-]|[«24""»]|[«30»]|[-4-]|[$$Disk allocation error :_]}
            <POP 20cb8-20cba StackAdj>                       Δ-4                {[-16-]|[«24""»]|[«30»]|[-4-]|[$$Disk allocation error :_]|[-4-]}
            <Lit 0x20cba>                                                       {[-16-]|[«24""»]|[«30»]|[-4-]|[$$Disk allocation error :_]|[$$…]}
                <Pointer.sp 0x20cba 12>                      Δ-4        
                <Const 0x20cbe 0x1.2>                        Δ-2        
                <Const 0x20cc2 0x1e.2>                       Δ-2        
                <Call 0x20cc6 0x102c4>
                    StringLit(Src : Pointer; Offset: W; Len : W) : String
                <POP 20cc8-20cca StackAdj>                   Δ+8        
            <Call 0x20cca 0x102d0>                                              {[-16-]|[«24""»]|[«30»]|[-4-]|[$$Disk allocation error :_]|[$$…]}
                StringCat2(a, b : String) : String
            <POP 20cd0-20cd2 StackAdj>                       Δ+8                {[-16-]|[«24""»]|[«30»]|[-4-]}
            <Call 0x20cd2 0x103e0>                                              {[-16-]|[«24""»]|[«30»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 20cd4-20cd8 StackAdj>                       Δ+58               {[-16-]}
        <POP 20cd8-20ce2 Naked>                              Σ-16 Δ+8   →0x20b82 ←0x20c86
            <POP 20cd8-20cda StackAdj>                       Δ+4                {[-12-]}
            <MI 20cda  ADDQ.L  #0x1,D5>                                         {[-12-]}
            <POP 20cdc-20cde StackAdj>                       Δ+4                {[-8-]}
            <MI 20cde  BRA     0x20b82>                                         {[-8-]}
        <POP 20ce2-20cec Naked>                              Σ-12 Δ+4   ↓ →0x20d00 ←0x20b82 ←0x20bb6
            <POP 20ce2-20ce4 StackAdj>                       Δ+4                {[-8-]}
            <MI 20ce4  MOVE.L  (A6-0x10),D0>                                    {[-8-]}
            <MI 20ce6  CMP.L   (A6-0x4),D0>                                     {[-8-]}
            <MI 20cea  BLE     0x20d00>                                         {[-8-]}
        <POP 20cec-20d00 Naked>                              Σ-8        ↓
            <MI 20cec  MOVE.L  D0,(A6-0x4)>                                     {[-8-]}
            <MI 20cf0  MOVEA.L (A6+0x8),A0>                                     {[-8-]}
            <MI 20cf4  MOVE.L  (A7+0x4),D0>                                     {[-8-]}
            <MI 20cf8  ASL.L   #0x2,D0>                                         {[-8-]}
            <MI 20cfa  MOVE.L  (A7),D1>                                         {[-8-]}
            <MI 20cfc  ADD.L   D0,D1>                                           {[-8-]}
            <MI 20cfe  MOVE.L  D1,(A0)>                                         {[-8-]}
        <POP 20d00-20d28 Naked>                              Σ-8        ↓ →0x20d2e ←0x20ce2
            <MI 20d00  MOVE.L  (A6-0x10),D0>                                    {[-8-]}
            <POP 0x20d02 LimitCheck 0x0 ≤ D0 ≤ 0x10>                            {[-8-]}
            <MI 20d0c  ASL.L   #0x2,D0>                                         {[-8-]}
            <MI 20d0e  LEA.L   0x2146c,A0>                                      {[-8-]}
            <MI 20d14  LEA.L   (A0+D0.L),A0>                                    {[-8-]}
            <MI 20d18  ADDQ.L  #0x1,(A0+0x500c)>                                {[-8-]}
            <MI 20d1c  MOVE.L  (A7),D1>                                         {[-8-]}
            <MI 20d1e  ADDQ.L  #0x1,D1>                                         {[-8-]}
            <MI 20d20  CMPI.L  #0x00000003,D1>                                  {[-8-]}
            <MI 20d26  BGT     0x20d2e>                                         {[-8-]}
        <POP 20d28-20d2e Naked>                              Σ-8 Δ+4    →0x20b7c
            <POP 20d28-20d2a StackAdj>                       Δ+4                {[-4-]}
            <MI 20d2a  BRA     0x20b7c>                                         {[-4-]}
        <POP 20d2e-20d3c Naked>                              Σ-8 Δ+4    ↓ →0x20d42 ←0x20d00
            <POP 20d2e-20d30 StackAdj>                       Δ+4                {[-4-]}
            <MI 20d30  MOVE.L  (A7),D0>                                         {[-4-]}
            <MI 20d32  ADDQ.L  #0x1,D0>                                         {[-4-]}
            <MI 20d34  CMPI.L  #0x000001ff,D0>                                  {[-4-]}
            <MI 20d3a  BGT     0x20d42>                                         {[-4-]}
        <POP 20d3c-20d42 Naked>                              Σ-4 Δ+4    →0x20ad4
            <POP 20d3c-20d3e StackAdj>                       Δ+4                {}
            <MI 20d3e  BRA     0x20ad4>                                         {}
        <POP 20d42-20d44 Naked>                              Σ-4 Δ+4    ↓ ←0x20d2e
            <POP 20d42-20d44 StackAdj>                       Δ+4                {}
        <POP 20d44-20d4c Epilogue>                           Σ0         

0x20d4c


@ 20d4c
        <LVAR  0x008 4(r)>
        <LVAR -0x002 @>
        <LVAR -0x402 @>
        <LVAR -0x408 @>
    <POP 20d4c-20e74 Body>                                              
        <POP 20d4c-20d62 Prologue>                           Σ0         ↓
        <POP 20d62-20d6c RegCacheLoad>                       Σ0         ↓
        <POP 20d6c-20e20 Naked>                              Σ0         ↓
            <MI 20d6c  MOVE.L  (A6+0x8),D4>                                     {}
            <MI 20d70  MOVE.L  #0x100,D3>                                       {}
            <Call 0x20d76 0x10294>                                              {}
                ?divs_d3_d4
            <POP 0x20d7c LimitCheck 0x0 ≤ D4 ≤ 0x7>                             {}
            <MI 20d86  ASL.L   #0x1,D4>                                         {}
            <MI 20d88  LEA.L   0x0,A0>                                          {}
            <MI 20d8c  LEA.L   (A0+D4.L),A0>                                    {}
            <MI 20d90  ADDA.L  #0x10012,A0>                                     {}
            <MI 20d96  CLR.L   D0>                                              {}
            <MI 20d98  MOVE.W  (A0),D0>                                         {}
            <MI 20d9a  ADD.L   D0,D3>                                           {}
            <POP 0x20d9c LimitCheck 0x0 ≤ D3 ≤ 0xffff>                          {}
            <MI 20da6  MOVE.W  D3,D6>                                           {}
            <Const 0x20da8 0x2.2>                            Δ-2                {[#2]}
            <MI 20dac  MOVE.W  D6,-(A7)>                     Δ-2                {[#2]|[2, 'D6']}
            <Const 0x20dae 0x1.4>                            Δ-4                {[#2]|[2, 'D6']|[##1]}
            <MI 20db2  LEA.L   (A6-0x402),A0>                                   {[#2]|[2, 'D6']|[##1]}
            <MI 20db6  MOVE.L  A0,-(A7)>                     Δ-4                {[#2]|[2, 'D6']|[##1]|[4, 'A0']}
            <Pointer.fp 0x20db8 <LVAR -0x002 @>>             Δ-4                {[#2]|[2, 'D6']|[##1]|[4, 'A0']|[@@-2]}
            <Call 0x20dbc 0x1036c>                                              {[#2]|[2, 'D6']|[##1]|[4, 'A0']|[@@-2]}
                RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
            <POP 20dc2-20dc4 StackAdj>                       Δ+12               {[#2]|[2, 'D6']}
            <POP 20dc4-20dc5 StackAdj>                       Δ+4                {}
            <Blob 0x20dc5 [4] @>                             Δ-4                {[«4""»]}
            <Blob 0x20dc8 [4] @>                             Δ-4                {[«4""»]|[«4""»]}
            <Blob 0x20dcc [4] @>                             Δ-4                {[«4""»]|[«4""»]|[«4""»]}
            <Blob 0x20dd0 [4] @>                             Δ-4                {[«4""»]|[«4""»]|[«4""»]|[«4""»]}
            <Blob 0x20dd4 [38] @>                            Δ-38               {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]}
            <POP 20de6-20de8 StackAdj>                       Δ-8                {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-8-]}
            <Lit 0x20de8 16>                                                    {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]|[$$Directory block_]}
            <MI 20df4  MOVE.L  (A6+0x8),(A7)>                                   {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]|[4, '(A6+0x8)']}
            <POP 20df2-20df4 StackAdj>                       Δ-8                {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]|[4, '(A6+0x8)']|[-8-]}
            <Call 0x20df8 0x102e4>                                              {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]|[4, '(A6+0x8)']|[-8-]}
                Long2String(a : Long) : String
            <Lit 0x20dfe 37>                                                    {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]|[4, '(A6+0x8)']|[-4-]|[$$ contains the most files.  Files are:]}
            <Call 0x20e0c 0x102d4>                                              {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]|[4, '(A6+0x8)']|[-4-]|[$$ contains the most files.  Files are:]}
                StringCat3(a, b, c : String) : String
            <POP 20e12-20e14 StackAdj>                       Δ+12               {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]}
            <Call 0x20e14 0x103e0>                                              {[«4""»]|[«4""»]|[«4""»]|[«4""»]|[«38""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 20e1a-20e1e StackAdj>                       Δ+58               {}
            <MI 20e1e  MOVEQ.L #0x00,D7>                                        {}
        <POP 20e20-20e3c Naked>                              Σ0         ↓ →0x20e62 ←0x20e62
            <POP 0x20e20 LimitCheck 0x0 ≤ D7 ≤ 0xf>                             {}
            <MI 20e2a  MOVE.L  D7,D0>                                           {}
            <MI 20e2c  ASL.L   #0x6,D0>                                         {}
            <MI 20e2e  LEA.L   (A6-0x408),A0>                                   {}
            <MI 20e32  MOVE.B  (A0+D0.L+#0x45),D1>                              {}
            <MI 20e36  LSL.B   #0x4,D1>                                         {}
            <MI 20e38  LSR.B   #0x7,D1>                                         {}
            <MI 20e3a  BNE     0x20e62>                                         {}
        <POP 20e3c-20e62 Naked>                              Σ0         ↓
            <Blob 0x20e3c [30] (A0+D0.L+#0x24)>              Δ-30               {[«30»]}
            <POP 20e48-20e4a StackAdj>                       Δ-4                {[«30»]|[-4-]}
            <Lit 0x20e4a>                                                       {[«30»]|[$$…]}
                <Pointer.sp 0x20e4a 4>                       Δ-4        
                <Const 0x20e4e 0x1.2>                        Δ-2        
                <Const 0x20e50 0x1e.2>                       Δ-2        
                <Call 0x20e54 0x102c4>
                    StringLit(Src : Pointer; Offset: W; Len : W) : String
                <POP 20e56-20e58 StackAdj>                   Δ+8        
            <Call 0x20e58 0x103e0>                                              {[«30»]|[$$…]}
                WriteConsoleStringCrLf(str : String)
            <POP 20e5e-20e62 StackAdj>                       Δ+34               {}
        <POP 20e62-20e6c Naked>                              Σ0         ↓ →0x20e20 ←0x20e20
            <MI 20e62  ADDQ.L  #0x1,D7>                                         {}
            <MI 20e64  CMPI.L  #0x0000000f,D7>                                  {}
            <MI 20e6a  BLE     0x20e20>                                         {}
        <POP 20e6c-20e74 Epilogue>                           Σ0         

0x20e74


@ 20e74
        <LVAR  0x010 4(r)>
        <LVAR  0x00c 4(r)>
        <LVAR  0x008 4(r)>
        <LVAR -0x402 2(w)>
        <LVAR -0x404 @ 2(w) 4(r)>
        <LVAR -0x40a 2(rw)>
        <LVAR -0x40b @ 1(r)>
    <POP 20e74-20fc6 Body>                                              
        <POP 20e74-20e8a Prologue>                           Σ0         ↓
        <POP 20e8a-20e9a RegCacheLoad>                       Σ0         ↓
        <POP 20e9a-20eb4 Naked>                              Σ0         ↓
            <MI 20e9a  MOVEA.L (A6+0xc),A0>                                     {}
            <MI 20e9e  CLR.W   (A0)>                                            {}
            <MI 20ea0  MOVEA.L (A6+0x10),A0>                                    {}
            <MI 20ea4  CLR.W   (A0)>                                            {}
            <MI 20ea6  MOVEA.L (A6+0x8),A0>                                     {}
            <MI 20eaa  CLR.W   (A0)>                                            {}
            <MI 20eac  MOVEQ.L #0x00,D7>                                        {}
            <MI 20eae  MOVEQ.L #0x00,D5>                                        {}
            <MI 20eb0  MOVEQ.L #0x00,D6>                                        {}
            <MI 20eb2  MOVE.W  #0xffff,(A6-0x40a)>                              {}
        <POP 20eb4-20ed4 Naked>                              Σ0         ↓ →0x20ee4 ←0x20fa2
            <MI 20eb4  MOVEA.L 0x25474,A0>                                      {}
            <MI 20eba  CLR.L   D0>                                              {}
            <MI 20ebc  MOVE.W  (A6-0x40a),D0>                                   {}
            <MI 20ebe  MOVE.L  D0,D1>                                           {}
            <MI 20ec0  ROR.L   #0x2,D1>                                         {}
            <MI 20ec2  ADDA.W  D1,A0>                                           {}
            <MI 20ec4  SWAP.W  D1>                                              {}
            <MI 20ec6  ROL.W   #0x3,D1>                                         {}
            <MI 20ec8  CLR.L   D2>                                              {}
            <MI 20eca  MOVE.B  (A0),D2>                                         {}
            <MI 20ecc  LSL.B   D1,D2>                                           {}
            <MI 20ece  LSR.B   #0x6,D2>                                         {}
            <MI 20ed0  CMP.W   #0x03,D2>                                        {}
            <MI 20ed2  BNE     0x20ee4>                                         {}
        <POP 20ed4-20ee4 Naked>                              Σ0         ↓
            <MI 20ed4  CLR.L   D1>                                              {}
            <MI 20ed6  MOVE.W  D6,D1>                                           {}
            <MI 20ed8  ADDQ.L  #0x1,D1>                                         {}
            <POP 0x20eda LimitCheck 0x0 ≤ D1 ≤ 0xffff>                          {}
            <MI 20ee0  MOVE.W  D1,D6>                                           {}
            <MI 20ee2  MOVEQ.L #0x01,D7>                                        {}
        <POP 20ee4-20ee8 Naked>                              Σ0         ↓ →0x20eec ←0x20eb4
            <MI 20ee4  CMP.W   #0x03,D2>                                        {}
            <MI 20ee6  BEQ     0x20eec>                                         {}
        <POP 20ee8-20eec Naked>                              Σ0         ↓ →0x20ef4
            <MI 20ee8  TST.B   D7>                                              {}
            <MI 20eea  BNE     0x20ef4>                                         {}
        <POP 20eec-20ef4 Naked>                              Σ0         ↓ →0x20fa2 ←0x20ee4
            <MI 20eec  CMPI.W  #0x4000,D6>                                      {}
            <MI 20ef0  BNE     0x20fa2>                                         {}
        <POP 20ef4-20f24 Naked>                              Σ0         ↓ →0x20f26 ←0x20ee8
            <MI 20ef4  MOVEA.L (A6+0xc),A0>                                     {}
            <MI 20ef8  CLR.L   D1>                                              {}
            <MI 20efa  MOVE.W  (A0),D1>                                         {}
            <MI 20efc  ADDQ.L  #0x1,D1>                                         {}
            <POP 0x20efe LimitCheck 0x0 ≤ D1 ≤ 0xffff>                          {}
            <MI 20f04  MOVE.W  D1,(A0)>                                         {}
            <MI 20f06  MOVEA.L (A6+0x10),A0>                                    {}
            <MI 20f0a  CLR.L   D1>                                              {}
            <MI 20f0c  MOVE.W  (A0),D1>                                         {}
            <MI 20f0e  CLR.L   D2>                                              {}
            <MI 20f10  MOVE.W  D6,D2>                                           {}
            <MI 20f12  ADD.L   D2,D1>                                           {}
            <POP 0x20f14 LimitCheck 0x0 ≤ D1 ≤ 0xffff>                          {}
            <MI 20f1a  MOVE.W  D1,(A0)>                                         {}
            <MI 20f1c  MOVEA.L (A6+0x8),A0>                                     {}
            <MI 20f20  CMP.W   (A0),D2>                                         {}
            <MI 20f22  BLS     0x20f26>                                         {}
        <POP 20f24-20f26 Naked>                              Σ0         ↓
            <MI 20f24  MOVE.W  D2,(A0)>                                         {}
        <POP 20f26-20f38 Naked>                              Σ0         ↓ →0x20f3c ←0x20ef4
            <MI 20f26  MOVE.W  D5,(A6-0x402)>                                   {}
            <MI 20f2a  MOVE.W  D2,(A6-0x404)>                                   {}
            <MI 20f2c  MOVE.L  (A6-0x404),0x10022>                              {}
            <MI 20f32  CMPI.W  #0x4000,D2>                                      {}
            <MI 20f36  BNE     0x20f3c>                                         {}
        <POP 20f38-20f3c Naked>                              Σ0         →0x20f48
            <MI 20f38  MOVE.W  D0,D5>                                           {}
            <MI 20f3a  BRA     0x20f48>                                         {}
        <POP 20f3c-20f48 Naked>                              Σ0         ↓ ←0x20f26
            <MI 20f3c  MOVE.L  D0,D1>                                           {}
            <MI 20f3e  ADDQ.L  #0x1,D1>                                         {}
            <POP 0x20f40 LimitCheck 0x0 ≤ D1 ≤ 0xffff>                          {}
            <MI 20f46  MOVE.W  D1,D5>                                           {}
        <POP 20f48-20f68 Naked>                              Σ0         ↓ →0x20f9e ←0x20f38
            <Const 0x20f48 0x3.2>                            Δ-2                {[#3]}
            <MI 20f4a  MOVE.W  D5,-(A7)>                     Δ-2                {[#3]|[2, 'D5']}
            <Const 0x20f4c 0x1.4>                            Δ-4                {[#3]|[2, 'D5']|[##1]}
            <MI 20f50  LEA.L   (A6-0x404),A0>                                   {[#3]|[2, 'D5']|[##1]}
            <MI 20f52  MOVE.L  A0,-(A7)>                     Δ-4                {[#3]|[2, 'D5']|[##1]|[4, 'A0']}
            <Pointer.fp 0x20f54 <LVAR -0x40b @ 1(r)>>        Δ-4                {[#3]|[2, 'D5']|[##1]|[4, 'A0']|[@@-1035]}
            <Call 0x20f58 0x1036c>                                              {[#3]|[2, 'D5']|[##1]|[4, 'A0']|[@@-1035]}
                RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
            <POP 20f5e-20f62 StackAdj>                       Δ+16               {}
            <MI 20f62  TST.B   (A6-0x40b)>                                      {}
            <MI 20f66  BNE     0x20f9e>                                         {}
        <POP 20f68-20f9e Naked>                              Σ0         ↓
            <Blob 0x20f68 [56] @>                            Δ-56               {[«56""»]}
            <Const 0x20f7a 0x1.2>                            Δ-2                {[«56""»]|[#1]}
            <POP 20f7e-20f80 StackAdj>                       Δ-4                {[«56""»]|[#1]|[-4-]}
            <Lit 0x20f80 55>                                                    {[«56""»]|[#1]|[$$Can't construct free list due to disk errors, aborting!]}
            <Call 0x20f94 0x103b8>                                              {[«56""»]|[#1]|[$$Can't construct free list due to disk errors, aborting!]}
                PopProgram(status : Byte; msg : String)
            <POP 20f9a-20f9e StackAdj>                       Δ+62               {}
        <POP 20f9e-20fa2 Naked>                              Σ0         ↓ ←0x20f48
            <MI 20f9e  MOVEQ.L #0x00,D6>                                        {}
            <MI 20fa0  MOVEQ.L #0x00,D7>                                        {}
        <POP 20fa2-20fb2 Naked>                              Σ0         ↓ →0x20eb4 ←0x20eec
            <MI 20fa2  SUBQ.L  #0x1,D0>                                         {}
            <POP 0x20fa4 LimitCheck 0x0 ≤ D0 ≤ 0xffff>                          {}
            <MI 20faa  MOVE.W  D0,(A6-0x40a)>                                   {}
            <MI 20fac  TST.W   D0>                                              {}
            <MI 20fae  BNE     0x20eb4>                                         {}
        <POP 20fb2-20fbe Naked>                              Σ0         ↓
            <MI 20fb2  MOVE.W  D5,0x10010>                                      {}
            <Call 0x20fb8 0x10390>                                              {}
                WriteFreeList(void)
        <POP 20fbe-20fc6 Epilogue>                           Σ0         

0x20fc6


@ 20fc6
START
    <POP 20fc6--0001 Body>                                              
        <POP 20fc6-20fd0 Prologue>                           Σ0         
        <POP 20fd0-20fee RegCacheLoad>                       Σ0         ↓
        <POP 20fee-2106a Naked>                              Σ0         ↓
            <MI 20fee  LEA.L   0x25478,A0>                                      {}
            <MI 20ff4  MOVE.L  A0,-(A7)>                     Δ-4                {[4, 'A0']}
            <MI 20ff6  MOVE.L  (A7)+,0x264be>                Δ+4                {}
            <MI 20ffc  LEA.L   0x21474,A0>                                      {}
            <MI 21002  MOVE.L  A0,-(A7)>                     Δ-4                {[4, 'A0']}
            <MI 21004  MOVE.L  (A7)+,0x25474>                Δ+4                {}
            <Call 0x2100a 0x10398>                                              {}
                FSCALL_10398
            <Call 0x21010 0x20562>                                              {}
            <Call 0x21014 0x205c4>                                              {}
            <Const 0x21018 0x264c2.4>                        Δ-4                {[##156866]}
            <Const 0x2101a 0x264c4.4>                        Δ-4                {[##156866]|[##156868]}
            <Const 0x2101c 0x264c6.4>                        Δ-4                {[##156866]|[##156868]|[##156870]}
            <Call 0x21022 0x20906>                                              {[##156866]|[##156868]|[##156870]}
            <POP 21026-21028 StackAdj>                       Δ+12               {}
            <Const 0x21028 0x264cc.4>                        Δ-4                {[##156876]}
            <Call 0x2102e 0x20a78>                                              {[##156876]}
            <POP 21032-21034 StackAdj>                       Δ+4                {}
            <Call 0x21034 0x103dc>                                              {}
                WriteConsoleCrLf(void)
            <Blob 0x2103a [24] @>                            Δ-24               {[«24""»]}
            <POP 2104c-2104e StackAdj>                       Δ-4                {[«24""»]|[-4-]}
            <Lit 0x2104e 23>                                                    {[«24""»]|[$$Directory utilization :]}
            <Call 0x21060 0x103e0>                                              {[«24""»]|[$$Directory utilization :]}
                WriteConsoleStringCrLf(str : String)
            <POP 21066-21068 StackAdj>                       Δ+28               {}
            <MI 21068  MOVEQ.L #0x01,D0>                                        {}
        <POP 2106a-21092 Naked>                              Σ0         ↓ →0x2106a ←0x2106a
            <MI 2106a  MOVE.L  D0,0x264c8>                                      {}
            <POP 21070-21072 StackAdj>                       Δ-8                {[-8-]}
            <MI 21072  MOVE.L  D0,-(A7)>                     Δ-4                {[-8-]|[4, 'D0']}
            <Call 0x21074 0x102e4>                                              {[-8-]|[4, 'D0']}
                Long2String(a : Long) : String
            <POP 21076-21078 StackAdj>                       Δ+4                {[-8-]}
            <Const 0x21078 0x5.4>                            Δ-4                {[-8-]|[##5]}
            <Call 0x2107c 0x102f4>                                              {[-8-]|[##5]}
                RightPad(a : String; b : Long) : String
            <POP 21082-21084 StackAdj>                       Δ+8                {[-4-]}
            <Call 0x21084 0x103d8>                                              {[-4-]}
                WriteConsoleString(str : String)
            <POP 2108a-2108c StackAdj>                       Δ+4                {}
            <MI 2108c  ADDQ.L  #0x1,D0>                                         {}
            <MI 2108e  CMP.L   #0x10,D0>                                        {}
            <MI 21090  BLE     0x2106a>                                         {}
        <POP 21092-2109a Naked>                              Σ0         ↓
            <Call 0x21092 0x103dc>                                              {}
                WriteConsoleCrLf(void)
            <MI 21098  MOVEQ.L #0x01,D0>                                        {}
        <POP 2109a-210d8 Naked>                              Σ0         ↓ →0x2109a ←0x2109a
            <MI 2109a  MOVE.L  D0,0x264c8>                                      {}
            <POP 210a0-210a2 StackAdj>                       Δ-8                {[-8-]}
            <POP 0x210a2 LimitCheck 0x0 ≤ D0 ≤ 0x10>                            {[-8-]}
            <MI 210a8  MOVE.L  D0,D1>                                           {[-8-]}
            <MI 210aa  ASL.L   #0x2,D1>                                         {[-8-]}
            <MI 210ac  LEA.L   0x2146c,A0>                                      {[-8-]}
            <MI 210b2  LEA.L   (A0+D1.L),A0>                                    {[-8-]}
            <MI 210b6  MOVE.L  (A0+0x500c),-(A7)>            Δ-4                {[-8-]|[4, '(A0+0x500c)']}
            <Call 0x210ba 0x102e4>                                              {[-8-]|[4, '(A0+0x500c)']}
                Long2String(a : Long) : String
            <POP 210bc-210be StackAdj>                       Δ+4                {[-8-]}
            <Const 0x210be 0x5.4>                            Δ-4                {[-8-]|[##5]}
            <Call 0x210c2 0x102f4>                                              {[-8-]|[##5]}
                RightPad(a : String; b : Long) : String
            <POP 210c8-210ca StackAdj>                       Δ+8                {[-4-]}
            <Call 0x210ca 0x103d8>                                              {[-4-]}
                WriteConsoleString(str : String)
            <POP 210d0-210d2 StackAdj>                       Δ+4                {}
            <MI 210d2  ADDQ.L  #0x1,D0>                                         {}
            <MI 210d4  CMP.L   #0x10,D0>                                        {}
            <MI 210d6  BLE     0x2109a>                                         {}
        <POP 210d8-211cc Naked>                              Σ0 Δ-32    ↓ →0x2124e
            <Call 0x210d8 0x103dc>                                              {}
                WriteConsoleCrLf(void)
            <Blob 0x210de [28] @>                            Δ-28               {[«28""»]}
            <POP 210ee-210f0 StackAdj>                       Δ-8                {[«28""»]|[-8-]}
            <Blob 0x210f0 [4] 0x26478>                       Δ-4                {[«28""»]|[-8-]|[«4»]}
            <Call 0x210f6 0x102e4>                                              {[«28""»]|[-8-]|[«4»]}
                Long2String(a : Long) : String
            <Lit 0x210f8 27>                                                    {[«28""»]|[-8-]|[$$ directory block are empty.]}
            <Call 0x2110a 0x102d0>                                              {[«28""»]|[-8-]|[$$ directory block are empty.]}
                StringCat2(a, b : String) : String
            <POP 21110-21112 StackAdj>                       Δ+8                {[«28""»]|[-4-]}
            <Call 0x21112 0x103e0>                                              {[«28""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 21118-2111c StackAdj>                       Δ+32               {}
            <Blob 0x2111c [18] @>                            Δ-18               {[«18""»]}
            <Blob 0x21128 [36] @>                            Δ-36               {[«18""»]|[«36""»]}
            <POP 21138-2113a StackAdj>                       Δ-8                {[«18""»]|[«36""»]|[-8-]}
            <MI 2113a  CLR.L   D0>                                              {[«18""»]|[«36""»]|[-8-]}
            <MI 2113c  MOVE.W  0x264c2,D0>                                      {[«18""»]|[«36""»]|[-8-]}
            <MI 2113e  MOVE.L  D0,-(A7)>                     Δ-4                {[«18""»]|[«36""»]|[-8-]|[4, 'D0']}
            <Call 0x21140 0x102e4>                                              {[«18""»]|[«36""»]|[-8-]|[4, 'D0']}
                Long2String(a : Long) : String
            <Lit 0x21142 18>                                                    {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]}
            <POP 21150-21152 StackAdj>                       Δ-4                {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]}
            <MI 21152  CLR.L   D0>                                              {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]}
            <MI 21154  MOVE.W  0x264c4,D0>                                      {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]}
            <MI 21156  MOVE.L  D0,-(A7)>                     Δ-4                {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[4, 'D0']}
            <Call 0x21158 0x102e4>                                              {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[4, 'D0']}
                Long2String(a : Long) : String
            <Lit 0x2115a 35>                                                    {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]}
            <POP 2116a-2116c StackAdj>                       Δ-4                {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <MI 2116c  CLR.L   D0>                                              {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <MI 2116e  MOVE.W  0x264c6,D0>                                      {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <MI 21174  MOVE.L  D0,-(A7)>                     Δ-4                {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]|[4, 'D0']}
            <Call 0x21176 0x102e4>                                              {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]|[4, 'D0']}
                Long2String(a : Long) : String
            <POP 21178-2117a StackAdj>                       Δ+4                {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <Call 0x2117a 0x102dc>                                              {[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
                StringCat5(a, b, c, d, e : String) : String
            <POP 21180-21184 StackAdj>                       Δ+20               {[«18""»]|[«36""»]|[-4-]}
            <Call 0x21184 0x103e0>                                              {[«18""»]|[«36""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 2118a-2118e StackAdj>                       Δ+54               {[-4-]}
            <POP 2118e-2118f StackAdj>                       Δ+4                {}
            <Blob 0x2118f [4] 0x264cc>                       Δ-4                {[«4»]}
            <Call 0x21194 0x20d4c>                                              {[«4»]}
            <POP 21198-21199 StackAdj>                       Δ+4        ↓       {}
            <Blob 0x21199 [32] @>                            Δ-32               {[«32""»]}
            <POP 211a8-211aa StackAdj>                       Δ-6                {[«32""»]|[-6-]}
            <Lit 0x211aa 31>                                                    {[«32""»]|[-2-]|[$$Do you want to compact the disk]}
            <POP 211ba-211bc StackAdj>                       Δ-2                {[«32""»]|[-2-]|[$$Do you want to compact the disk]|[-2-]}
            <MI 211bc  CLR.B   (A7)>                                            {[«32""»]|[-2-]|[$$Do you want to compact the disk]|[-2-]}
            <Call 0x211be 0x103f0>                                              {[«32""»]|[-2-]|[$$Do you want to compact the disk]|[-2-]}
                AskOnConsoleYesNo(prompt : String; default : Bool) : Bool
            <POP 211c4-211c6 StackAdj>                       Δ+6                {[«32""»]|[-2-]}
            <MI 211c6  TST.B   (A7)+>                        Δ+2                {[«32""»]}
            <MI 211c8  BEQ     0x2124e>                                         {[«32""»]}
        <POP 211cc-2124e Naked>                              Σ-32       ↓
            <Const 0x211cc 0x264c2.4>                        Δ-4                {[-32-]|[##156866]}
            <Const 0x211ce 0x264c4.4>                        Δ-4                {[-32-]|[##156866]|[##156868]}
            <Const 0x211d0 0x264c6.4>                        Δ-4                {[-32-]|[##156866]|[##156868]|[##156870]}
            <Call 0x211d6 0x20e74>                                              {[-32-]|[##156866]|[##156868]|[##156870]}
            <POP 211da-211dc StackAdj>                       Δ+12               {[-32-]}
            <Blob 0x211dc [18] @>                            Δ-18               {[-32-]|[«18""»]}
            <Blob 0x211e8 [36] @>                            Δ-36               {[-32-]|[«18""»]|[«36""»]}
            <POP 211f8-211fa StackAdj>                       Δ-8                {[-32-]|[«18""»]|[«36""»]|[-8-]}
            <MI 211fa  CLR.L   D0>                                              {[-32-]|[«18""»]|[«36""»]|[-8-]}
            <MI 211fc  MOVE.W  0x264c2,D0>                                      {[-32-]|[«18""»]|[«36""»]|[-8-]}
            <MI 211fe  MOVE.L  D0,-(A7)>                     Δ-4                {[-32-]|[«18""»]|[«36""»]|[-8-]|[4, 'D0']}
            <Call 0x21200 0x102e4>                                              {[-32-]|[«18""»]|[«36""»]|[-8-]|[4, 'D0']}
                Long2String(a : Long) : String
            <Lit 0x21202 18>                                                    {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]}
            <POP 21210-21212 StackAdj>                       Δ-4                {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]}
            <MI 21212  CLR.L   D0>                                              {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]}
            <MI 21214  MOVE.W  0x264c4,D0>                                      {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]}
            <MI 21216  MOVE.L  D0,-(A7)>                     Δ-4                {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[4, 'D0']}
            <Call 0x21218 0x102e4>                                              {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[4, 'D0']}
                Long2String(a : Long) : String
            <Lit 0x2121a 35>                                                    {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]}
            <POP 2122a-2122c StackAdj>                       Δ-4                {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <MI 2122c  CLR.L   D0>                                              {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <MI 2122e  MOVE.W  0x264c6,D0>                                      {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <MI 21234  MOVE.L  D0,-(A7)>                     Δ-4                {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]|[4, 'D0']}
            <Call 0x21236 0x102e4>                                              {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]|[4, 'D0']}
                Long2String(a : Long) : String
            <POP 21238-2123a StackAdj>                       Δ+4                {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
            <Call 0x2123a 0x102dc>                                              {[-32-]|[«18""»]|[«36""»]|[-8-]|[$$ blocks unused in_]|[-4-]|[$$ segments.  Largest unused block =_]|[-4-]}
                StringCat5(a, b, c, d, e : String) : String
            <POP 21240-21244 StackAdj>                       Δ+20               {[-32-]|[«18""»]|[«36""»]|[-4-]}
            <Call 0x21244 0x103e0>                                              {[-32-]|[«18""»]|[«36""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 2124a-2124e StackAdj>                       Δ+58               {[-32-]}
        <POP 2124e-21260 Naked>                              Σ-32 Δ+32  ↓ ←0x210d8
            <POP 2124e-21252 StackAdj>                       Δ+30               {[-2-]}
            <MI 21252  CLR.B   (A7)>                                            {[-2-]}
            <Const 0x21254 0x1.4>                            Δ-4                {[-2-]|[##1]}
            <Call 0x21258 0x103b8>                                              {[-2-]|[##1]}
                PopProgram(status : Byte; msg : String)
            <POP 2125e-21260 StackAdj>                       Δ+6                {}
        <POP 21260-21266 Naked>                              Σ0         
            <Call 0x21260 0x10284>                                              {}
                ?exit

0x21274


@ 21274
PROG_FAIL
        <LVAR  0x008 1(r)>
    <POP 21274-212dc Body>                                              
        <POP 21274-2128a Prologue>                           Σ0         ↓
        <POP 2128a-212d4 Naked>                              Σ0         ↓
            <Blob 0x2128a [14] @>                            Δ-14               {[«14""»]}
            <Const 0x21296 0x3.2>                            Δ-2                {[«14""»]|[#3]}
            <POP 2129a-2129c StackAdj>                       Δ-8                {[«14""»]|[#3]|[-8-]}
            <Lit 0x2129c 14>                                                    {[«14""»]|[#3]|[-4-]|[$$Words error :_]}
            <POP 212ae-212b0 StackAdj>                       Δ-4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 212b0  MOVE.B  (A6+0x8),D0>                                     {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 212b4  EXTB.W  D0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 212b6  EXTW.L  D0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 212b8  MOVE.L  D0,-(A7)>                     Δ-4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]|[4, 'D0']}
            <Call 0x212ba 0x102e4>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]|[4, 'D0']}
                Long2String(a : Long) : String
            <POP 212c0-212c2 StackAdj>                       Δ+4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <Call 0x212c2 0x102d0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
                StringCat2(a, b : String) : String
            <POP 212c8-212ca StackAdj>                       Δ+8                {[«14""»]|[#3]|[-4-]}
            <Call 0x212ca 0x103b8>                                              {[«14""»]|[#3]|[-4-]}
                PopProgram(status : Byte; msg : String)
            <POP 212d0-212d4 StackAdj>                       Δ+20               {}
        <POP 212d4-212dc Epilogue>                           Σ0         

0x21330


@ 21330
EXP_FAIL
        <LVAR  0x00e 1(r)>
        <LVAR  0x00a 4(r)>
        <LVAR  0x008 1(r)>
    <POP 21330-2146c Body>                                              
        <POP 21330-21346 Prologue>                           Σ0         ↓
        <POP 21346-2135c RegCacheLoad>                       Σ0         ↓
        <POP 2135c-213bc Naked>                              Σ0         ↓ →0x21404
            <Call 0x2135c 0x103dc>                                              {}
                WriteConsoleCrLf(void)
            <Blob 0x21362 [18] @>                            Δ-18               {[«18""»]}
            <POP 2136e-21370 StackAdj>                       Δ-4                {[«18""»]|[-4-]}
            <Lit 0x21370 18>                                                    {[«18""»]|[$$Experiment error :]}
            <Call 0x2137c 0x103e0>                                              {[«18""»]|[$$Experiment error :]}
                WriteConsoleStringCrLf(str : String)
            <POP 2137e-2137f StackAdj>                       Δ+22       ↓       {}
            <Blob 0x2137f [14] @>                            Δ-14               {[«14""»]}
            <POP 2138e-21390 StackAdj>                       Δ-8                {[«14""»]|[-8-]}
            <Lit 0x21390 13>                                                    {[«14""»]|[-4-]|[$$Board      :_]}
            <POP 2139a-2139c StackAdj>                       Δ-6                {[«14""»]|[-4-]|[$$Board      :_]|[-6-]}
            <MI 2139c  MOVE.B  (A6+0xe),(A7)>                                   {[«14""»]|[-4-]|[$$Board      :_]|[-6-]}
            <Call 0x213a0 0x1049c>                                              {[«14""»]|[-4-]|[$$Board      :_]|[-6-]}
                BoardName(address : B) : String
            <POP 213a6-213a8 StackAdj>                       Δ+2                {[«14""»]|[-4-]|[$$Board      :_]|[-4-]}
            <Call 0x213a8 0x102d0>                                              {[«14""»]|[-4-]|[$$Board      :_]|[-4-]}
                StringCat2(a, b : String) : String
            <POP 213ae-213b0 StackAdj>                       Δ+8                {[«14""»]|[-4-]}
            <Call 0x213b0 0x103e0>                                              {[«14""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 213b2-213b4 StackAdj>                       Δ+18               {}
            <MI 213b4  MOVEA.L (A6+0xa),A0>                                     {}
            <MI 213b8  CMPA.W  #0x01,A0>                                        {}
            <MI 213ba  BEQ     0x21404>                                         {}
        <POP 213bc-21404 Naked>                              Σ0         ↓
            <Blob 0x213bc [14] @>                            Δ-14               {[«14""»]}
            <Blob 0x213cc [30] (A0+0xfc)>                    Δ-30               {[«14""»]|[«30»]}
            <POP 213dc-213de StackAdj>                       Δ-8                {[«14""»]|[«30»]|[-8-]}
            <Lit 0x213de 13>                                                    {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]}
            <POP 213e8-213ea StackAdj>                       Δ-4                {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]|[-4-]}
            <Lit 0x213ea>                                                       {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]|[$$…]}
                <Pointer.sp 0x213ea 12>                      Δ-4        
                <Const 0x213ee 0x1.2>                        Δ-2        
                <Const 0x213f0 0x1e.2>                       Δ-2        
                <Call 0x213f2 0x102c4>
                    StringLit(Src : Pointer; Offset: W; Len : W) : String
                <POP 213f4-213f6 StackAdj>                   Δ+8        
            <Call 0x213f6 0x102d0>                                              {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]|[$$…]}
                StringCat2(a, b : String) : String
            <POP 213fc-213fe StackAdj>                       Δ+8                {[«14""»]|[«30»]|[-4-]}
            <Call 0x213fe 0x103e0>                                              {[«14""»]|[«30»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 21400-21404 StackAdj>                       Δ+48               {}
        <POP 21404-21464 Naked>                              Σ0         ↓ ←0x2135c
            <Blob 0x21404 [14] @>                            Δ-14               {[«14""»]}
            <POP 21414-21416 StackAdj>                       Δ-8                {[«14""»]|[-8-]}
            <Lit 0x21416 13>                                                    {[«14""»]|[-4-]|[$$Status     :_]}
            <POP 21420-21422 StackAdj>                       Δ-6                {[«14""»]|[-4-]|[$$Status     :_]|[-6-]}
            <MI 21422  MOVE.B  (A6+0x8),(A7)>                                   {[«14""»]|[-4-]|[$$Status     :_]|[-6-]}
            <Call 0x21426 0x104a2>                                              {[«14""»]|[-4-]|[$$Status     :_]|[-6-]}
                ExpStatus2Text(status.B, &String)
            <POP 2142c-2142e StackAdj>                       Δ+2                {[«14""»]|[-4-]|[$$Status     :_]|[-4-]}
            <Call 0x2142e 0x102d0>                                              {[«14""»]|[-4-]|[$$Status     :_]|[-4-]}
                StringCat2(a, b : String) : String
            <POP 21434-21436 StackAdj>                       Δ+8                {[«14""»]|[-4-]}
            <Call 0x21436 0x103e0>                                              {[«14""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 21438-21439 StackAdj>                       Δ+18       ↓       {}
            <Blob 0x21439 [24] @>                            Δ-24               {[«24""»]}
            <Const 0x21448 0x2.2>                            Δ-2                {[«24""»]|[#2]}
            <POP 2144c-2144e StackAdj>                       Δ-4                {[«24""»]|[#2]|[-4-]}
            <Lit 0x2144e 23>                                                    {[«24""»]|[#2]|[$$Fatal experiment error.]}
            <Call 0x2145c 0x103b8>                                              {[«24""»]|[#2]|[$$Fatal experiment error.]}
                PopProgram(status : Byte; msg : String)
            <POP 21462-21464 StackAdj>                       Δ+30               {}
        <POP 21464-2146c Epilogue>                           Σ0         

Raw from R1000.Disassembly/DFS

00020000 ; --------------------------------------------------------------------------------------
00020000 ; R1000.Disassembly modules:
00020000 ;   import all
00020000 ;   import kind.program
00020000 ;   no ident.f3e23d8914c5a89a
00020000 ; --------------------------------------------------------------------------------------
00020000					stack.top:
00020000 00 04 00 00              |        |		.CODE	0x40000			; STACK.END
00020004 00 02 0f c6              |        |		.CODE	START
00020008 00 01 02 88              |        |		.CODE	FSCALL_10288
0002000c					heap.top:
0002000c 00 02 64 e0              |  d     |		.PTR	0x264e0
00020010					code.end:
00020010 00 02 14 6c              |   l    |		.PTR	0x2146c
00020014 00 00 00 00              |        |		.CONST	0x00000000
00020018					programfailurehandler:
00020018 00 02 12 74              |   t    |		.CODE	PROG_FAIL
0002001c					experimentfailurehandler:
0002001c 00 02 13 30              |   0    |		.CODE	EXP_FAIL
00020020 00 00 00 00              |        |		.CONST	0x00000000
00020024					exp_init_done:
00020024 00                       |        |		.CONST	0x00
00020025 00                       |        |		.CONST	0x00
00020026 00 00                    |        |		.CONST	0x0000
00020028 00 00                    |        |		.CONST	0x0000
0002002a 00 00                    |        |		.XXX[0x2]
0002002c 00 00                    |        |		.CONST	0x0000
0002002e 00 00                    |        |		.CONST	0x0000
00020030 00 00                    |        |		.CONST	0x0000
00020032 00 00 00 00 00 00        |        |		.XXX[0x6]
00020038 00 00 00 00 00 00 00 00  |        |		.BLANK	00[0xb0]
000200e8 00 00 00 00              |        |		.XXX[0x4]
000200ec 00 00 00 00              |        |		.PTR	0x0
000200f0					is_open_ERROR_LOG:
000200f0 00                       |        |		.CONST	0x0
000200f1					write_error_ERROR_LOG:
000200f1 00                       |        |		.CONST	0x0
000200f2 00 00 00 00              |        |		.CONST	0x00000000
000200f6 00 00 00 00              |        |		.CONST	0x00000000
000200fa 00                       |        |		.CONST	0x00
000200fb 00                       |        |		.CONST	0x00
000200fc					file_ERROR_LOG:
000200fc 00 00 00 00              |        |		.CONST	0x00000000
00020100 00 00 00 00              |        |		.CONST	0x00000000
00020104 00 00                    |        |		.CONST	0x0000
00020106 00 00                    |        |		.CONST	0x0000
00020108					somekindoffsflag:
00020108 00                       |        |		.CONST	0x00
00020109 00                       |        |		.CONST	0x00
0002010a 4d 49 53 53 49 4e        |MISSIN  |		.XXX[0x6]
00020110 47 20 20 20 46 49 58 45  |G   FIXE|		.XXX[0x38]
00020118 44 20 20 20 20 20 46 49  |D     FI|
00020120 4c 45 20 20 20 20 20 20  |LE      |
00020128 4c 49 53 54 20 20 20 20  |LIST    |
00020130 20 20 20 72 65 2d 61 6c  |   re-al|
00020138 6c 6f 63 61 74 65 73 20  |locates |
00020140 61 5f 20 62 6c 6f 63 6b  |a_ block|
00020148 2e 20                    |.       |		.XXX[0x2]
0002014a 43 61 6e 27 74 20 72 65  |Can't re|		.TXT	'Can't read volume label due to disk errors. '
00020176 4c 6f 61 64 69 6e 67 20  |Loading |		.TXT	'Loading directory blocks. '
00020190 55 6e 75 73 65 64 2f 6d  |Unused/m|		.XXX[0x38]
00020198 69 73 73 69 6e 67 20 20  |issing  |
000201a0 20 20 20 20 44 69 72 65  |    Dire|
000201a8 63 74 6f 72 79 2f 6c 61  |ctory/la|
000201b0 62 65 6c 20 20 20 20 20  |bel     |
000201b8 46 69 6c 65 20 20 20 20  |File    |
000201c0 20 20 20 20 20 20 20 20  |        |
000201c8 20 20 20 20              |        |		.XXX[0x4]
000201cc 46 72 65 65              |Free    |		.XXX[0x4]
000201d0 20 6c 69 73 74 20 20 20  | list   |		.XXX[0x10]
000201d8 20 20 20 20 20 20 20 20  |        |
000201e0 20 62 6c 6f 63 6b 20 69  | block i|		.TXT	' block is already allocated to a_ '
00020202 20 62 6c 6f 63 6b 21 20  | block! |		.TXT	' block! '
0002020a 44 69 73 6b 20 65 72 72  |Disk err|		.TXT	'Disk error on free list read! '
00020228 5a 65 72 6f 20 6c 65 6e  |Zero len|		.TXT	'Zero length extent on free list!'
00020248 4c 6f 61 64 69 6e 67 20  |Loading |		.TXT	'Loading free list.'
0002025a 52 65 6d 61 69 6e 64 65  |Remainde|		.TXT	'Remainder of list will not be loaded'
0002027e 44 69 72 65 63 74 6f 72  |Director|		.TXT	'Directory read error! '
00020294 53 63 61 6e 6e 69 6e 67  |Scanning|		.TXT	'Scanning directory. '
000202a8 46 69 6c 65 20 69 73 20  |File is |		.TXT	'File is non-contiguous :_ '
000202c2 44 69 73 6b 20 61 6c 6c  |Disk all|		.TXT	'Disk allocation error :_'
000202da 44 69 72 65              |Dire    |		.TXT	'Dire'
000202de 63 74 6f 72              |ctor    |		.TXT	'ctor'
000202e2 79 20 62 6c              |y bl    |		.TXT	'y bl'
000202e6 6f 63 6b 5f              |ock_    |		.TXT	'ock_'
000202ea 20 63 6f 6e 74 61 69 6e  | contain|		.TXT	' contains the most files.  Files are: '
00020310 43 61 6e 27 74 20 63 6f  |Can't co|		.TXT	'Can't construct free list due to disk errors, aborting! '
00020348 44 6f 20 79 6f 75 20 77  |Do you w|		.TXT	'Do you want to compact the disk '
00020368 44 69 72 65 63 74 6f 72  |Director|		.TXT	'Directory utilization : '
00020380 20 64 69 72 65 63 74 6f  | directo|		.TXT	' directory block are empty. '
0002039c 20 62 6c 6f 63 6b 73 20  | blocks |		.TXT	' blocks unused in_'
000203ae 20 73 65 67 6d 65 6e 74  | segment|		.TXT	' segments.  Largest unused block =_ '
000203d2 20 62 6c 6f 63 6b 73 20  | blocks |		.TXT	' blocks unused in_'
000203e4 20 73 65 67 6d 65 6e 74  | segment|		.TXT	' segments.  Largest unused block =_ '
00020408 4d 49 53 53 49 4e 47 20  |MISSING |		.XXX[0x60]
00020410 20 20 46 49 58 45 44 20  |  FIXED |
00020418 20 20 20 20 46 49 4c 45  |    FILE|
00020420 20 20 20 20 20 20 4c 49  |      LI|
00020428 53 54 20 20 20 20 20 20  |ST      |
00020430 55 6e 75 73 65 64 2f 6d  |Unused/m|
00020438 69 73 73 69 6e 67 20 20  |issing  |
00020440 20 20 20 20 44 69 72 65  |    Dire|
00020448 63 74 6f 72 79 2f 6c 61  |ctory/la|
00020450 62 65 6c 20 20 20 20 20  |bel     |
00020458 46 69 6c 65 20 20 20 20  |File    |
00020460 20 20 20 20 20 20 20 20  |        |
00020468 20 20 20 20              |        |		.XXX[0x4]
0002046c 46 72 65 65              |Free    |		.XXX[0x4]
00020470 20 6c 69 73 74 20 20 20  | list   |		.XXX[0xf0]
00020478 20 20 20 20 20 20 20 20  |        |
00020480 4e 56 ff 8c bf d5 62 06  |NV    b |
00020488 44 fc 00 02 4e 76 de fc  |D   Nv  |
00020490 00 74 48 e7 fe e0 45 f9  | tH   E |
00020498 00 01 02 c4 72 0a 74 01  |    r t |
000204a0 7a 03 7c 10 20 2e 00 08  |z |  .  |
000204a8 b0 85 63 02 4e 4f 28 00  |  c NO( |
000204b0 76 0a 4e b9 00 01 02 8c  |v N     |
000204b8 41 fa ff 4e 9e c1 22 4f  |A  N  "O|
000204c0 41 f0 48 00 70 09 12 d8  |A H p   |
000204c8 51 c8 ff fc 2f 3a fc 70  |Q   /: p|
000204d0 2f 3a fc 68 2f 3a fc 60  |/: h/: `|
000204d8 2f 3a fc 58 20 2e 00 0c  |/: X .  |
000204e0 b0 85 63 02 4e 4f 28 00  |  c NO( |
000204e8 76 0a 4e b9 00 01 02 8c  |v N     |
000204f0 41 fa ff 16 9e c1 22 4f  |A     "O|
000204f8 41 f0 48 00 70 09 12 d8  |A H p   |
00020500 51 c8 ff fc 51 4f 20 4f  |Q   QO O|
00020508 43 fa fc 38 70 06 10 d9  |C  8p   |
00020510 51 c8 ff fc 51 4f 48 6f  |Q   QOHo|
00020518 00 2a 3f 02 3f 01 4e 92  | *? ? N |
00020520 58 4f 48 6f 00 1e 3f 02  |XOHo  ? |
00020528 3f 06 4e 92 58 4f 48 6f  |? N XOHo|
00020530 00 18 3f 02 3f 01 4e 92  |  ? ? N |
00020538 58 4f 48 6f 00 14 3f 02  |XOHo  ? |
00020540 3f 3c 00 07 4e 92 50 4f  |?<  N PO|
00020548 4e b9 00 01 02 d8 de c6  |N       |
00020550 4e b9 00 01 03 e0 de fc  |N       |
00020558 00 30 4c df 07 7f 4e 5e  | 0L   N^|
00020560 4e 75                    |Nu      |		.XXX[0x2]
00020562 ; --------------------------------------------------------------------------------------
00020562 ; OMSI PASCAL Function
00020562 ; --------------------------------------------------------------------------------------
00020562 4e 56 ff e0              |NV      |		LINK.W	A6,#0xffe0
00020566 bf d5                    |        |		CMPA.L	(A5),A7
00020568 62 06                    |b       |		BHI	0x20570
0002056a 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
0002056e 4e 76                    |Nv      |		TRAPV
00020570 de fc 00 1c              |        |		ADDA.W	#0x1c,A7
00020574 48 e7 c1 c0              |H       |		MOVEM.L	A1+A0+D7+D1+D0,-(A7)
00020578 43 f9 00 02 14 6c        |C    l  |		LEA.L	0x2146c,A1
0002057e 72 10                    |r       |		MOVEQ.L	#0x10,D1
00020580 7e 00                    |~       |		MOVEQ.L	#0x00,D7
00020582 be 81                    |        |		CMP.L	D1,D7
00020584 63 02                    |c       |		BLS	0x20588
00020586 4e 4f                    |NO      |		TRAP	#15
00020588 20 07                    |        |		MOVE.L	D7,D0
0002058a e5 80                    |        |		ASL.L	#0x2,D0
0002058c 20 49                    | I      |		MOVEA.L	A1,A0
0002058e 41 f0 08 00              |A       |		LEA.L	(A0+D0.L),A0
00020592 42 a8 50 0c              |B P     |		CLR.L	(A0+0x500c)
00020596 52 87                    |R       |		ADDQ.L	#0x1,D7
00020598 be 81                    |        |		CMP.L	D1,D7
0002059a 6f e6                    |o       |		BLE	0x20582
0002059c 7e 00                    |~       |		MOVEQ.L	#0x00,D7
0002059e 0c 87 00 00 1f ff        |        |		CMPI.L	#0x00001fff,D7
000205a4 63 02                    |c       |		BLS	0x205a8
000205a6 4e 4f                    |NO      |		TRAP	#15
000205a8 20 07                    |        |		MOVE.L	D7,D0
000205aa e3 80                    |        |		ASL.L	#0x1,D0
000205ac 20 49                    | I      |		MOVEA.L	A1,A0
000205ae 42 70 08 08              |Bp      |		CLR.W	(A0+D0.L+#0x8)
000205b2 52 87                    |R       |		ADDQ.L	#0x1,D7
000205b4 0c 87 00 00 1f ff        |        |		CMPI.L	#0x00001fff,D7
000205ba 6f e2                    |o       |		BLE	0x2059e
000205bc 4c df 03 83              |L       |		MOVEM.L	(A7)+,D0+D1+D7+A0+A1
000205c0 4e 5e                    |N^      |		UNLK	A6
000205c2 4e 75                    |Nu      |		RTS
000205c4 ; --------------------------------------------------------------------------------------
000205c4 ; OMSI PASCAL Function
000205c4 ;    <LVAR -0x002 2(rw)>
000205c4 ;    <LVAR -0x004 2(rw)>
000205c4 ;    <LVAR -0x3e1 1(r)>
000205c4 ;    <LVAR -0x3e2 1(r)>
000205c4 ;    <LVAR -0x3e4 2(r)>
000205c4 ;    <LVAR -0x3e5 1(r)>
000205c4 ;    <LVAR -0x3e6 1(r)>
000205c4 ;    <LVAR -0x3e8 2(r)>
000205c4 ;    <LVAR -0x404 @>
000205c4 ; --------------------------------------------------------------------------------------
000205c4 4e 56 fb 86              |NV      |		LINK.W	A6,#0xfb86
000205c8 bf d5                    |        |		CMPA.L	(A5),A7
000205ca 62 06                    |b       |		BHI	0x205d2
000205cc 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
000205d0 4e 76                    |Nv      |		TRAPV
000205d2 de fc 00 6e              |   n    |		ADDA.W	#0x6e,A7
000205d6 48 e7 ff f0              |H       |		MOVEM.L	A3+A2+A1+A0+D7+D6+D5+D4+D3+D2+D1+D0,-(A7)
000205da 45 f9 00 02 54 74        |E   Tt  |		LEA.L	0x25474,A2
000205e0 47 f9 00 02 64 bc        |G   d   |		LEA.L	0x264bc,A3
000205e6 28 3c 00 00 ff ff        |(<      |		MOVE.L	#0xffff,D4
000205ec 9e fc 00 1a              |        |		SUBA.W	#0x1a,A7
000205f0 20 4f                    | O      |		MOVEA.L	A7,A0
000205f2 43 fa fb 82              |C       |		LEA.L	0x20176,A1
000205f6 70 18                    |p       |		MOVEQ.L	#0x18,D0
000205f8 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000205fa 51 c8 ff fc              |Q       |		DBF	D0,0x205f8
000205fe 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020600 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
00020604 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020608 3f 3c 00 19              |?<      |		MOVE.W	#0x19,-(A7)
0002060c 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00020612 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020614 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
0002061a de fc 00 1e              |        |		ADDA.W	#0x1e,A7
0002061e 7c 00                    ||       |		MOVEQ.L	#0x00,D6
00020620 0c 86 00 00 00 07        |        |		CMPI.L	#0x00000007,D6
00020626 63 02                    |c       |		BLS	0x2062a
00020628 4e 4f                    |NO      |		TRAP	#15
0002062a 20 06                    |        |		MOVE.L	D6,D0
0002062c e3 80                    |        |		ASL.L	#0x1,D0
0002062e 41 f8 00 00              |A       |		LEA.L	0x0,A0
00020632 41 f0 08 00              |A       |		LEA.L	(A0+D0.L),A0
00020636 d1 fc 00 01 00 12        |        |		ADDA.L	#0x10012,A0
0002063c 3a 10                    |:       |		MOVE.W	(A0),D5
0002063e 42 80                    |B       |		CLR.L	D0
00020640 30 05                    |0       |		MOVE.W	D5,D0
00020642 06 80 00 00 00 ff        |        |		ADDI.L	#0x000000ff,D0
00020648 2f 00                    |/       |		MOVE.L	D0,-(A7)
0002064a 42 80                    |B       |		CLR.L	D0
0002064c 30 05                    |0       |		MOVE.W	D5,D0
0002064e 2e 00                    |.       |		MOVE.L	D0,D7
00020650 be 97                    |        |		CMP.L	(A7),D7
00020652 62 08                    |b       |		BHI	0x2065c
00020654 20 17                    |        |		MOVE.L	(A7),D0
00020656 be 80                    |        |		CMP.L	D0,D7
00020658 6d 02                    |m       |		BLT	0x2065c
0002065a 4e 4f                    |NO      |		TRAP	#15
0002065c be 6f 00 02              | o      |		CMP.W	(A7+0x2),D7
00020660 62 20                    |b       |		BHI	0x20682
00020662 20 52                    | R      |		MOVEA.L	(A2),A0
00020664 42 80                    |B       |		CLR.L	D0
00020666 30 07                    |0       |		MOVE.W	D7,D0
00020668 e4 98                    |        |		ROR.L	#0x2,D0
0002066a d0 c0                    |        |		ADDA.W	D0,A0
0002066c 48 40                    |H@      |		SWAP.W	D0
0002066e e7 58                    | X      |		ROL.W	#0x3,D0
00020670 72 40                    |r@      |		MOVEQ.L	#0x40,D1
00020672 34 3c ff 3f              |4< ?    |		MOVE.W	#0xff3f,D2
00020676 e0 7a                    | z      |		ROR.W	D0,D2
00020678 c5 10                    |        |		AND.B	D2,(A0)
0002067a e0 29                    | )      |		LSR.B	D0,D1
0002067c 83 10                    |        |		OR.B	D1,(A0)
0002067e 52 47                    |RG      |		ADDQ.W	#0x1,D7
00020680 64 da                    |d       |		BCC	0x2065c
00020682 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020684 52 86                    |R       |		ADDQ.L	#0x1,D6
00020686 0c 86 00 00 00 07        |        |		CMPI.L	#0x00000007,D6
0002068c 6f 92                    |o       |		BLE	0x20620
0002068e 1f 3c 00 02              | <      |		MOVE.B	#0x02,-(A7)
00020692 3f 3c 00 02              |?<      |		MOVE.W	#0x2,-(A7)
00020696 48 78 00 01              |Hx      |		PEA.L	0x1
0002069a 41 ee fb fc              |A       |		LEA.L	(A6-0x404),A0
0002069e 2f 08                    |/       |		MOVE.L	A0,-(A7)
000206a0 48 53                    |HS      |		PEA.L	(A3)
000206a2 4e b9 00 01 03 6c        |N    l  |		JSR	RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
000206a8 de fc 00 10              |        |		ADDA.W	#0x10,A7
000206ac 4a 13                    |J       |		TST.B	(A3)
000206ae 66 36                    |f6      |		BNE	0x206e6
000206b0 9e fc 00 2c              |   ,    |		SUBA.W	#0x2c,A7
000206b4 20 4f                    | O      |		MOVEA.L	A7,A0
000206b6 43 fa fa 92              |C       |		LEA.L	0x2014a,A1
000206ba 70 2a                    |p*      |		MOVEQ.L	#0x2a,D0
000206bc 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000206be 51 c8 ff fc              |Q       |		DBF	D0,0x206bc
000206c2 1f 3c 00 0e              | <      |		MOVE.B	#0x0e,-(A7)
000206c6 59 4f                    |YO      |		SUBQ.L	#0x4,A7
000206c8 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
000206cc 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
000206d0 3f 3c 00 2b              |?< +    |		MOVE.W	#0x2b,-(A7)
000206d4 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
000206da 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000206dc 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
000206e2 de fc 00 32              |   2    |		ADDA.W	#0x32,A7
000206e6 30 39 00 01 00 0c        |09      |		MOVE.W	0x1000c,D0
000206ec c0 ee fc 18              |        |		MULU.W	(A6-0x3e8),D0
000206f0 42 81                    |B       |		CLR.L	D1
000206f2 12 2e fc 1a              | .      |		MOVE.B	(A6-0x3e6),D1
000206f6 c2 f9 00 01 00 0a        |        |		MULU.W	0x1000a,D1
000206fc d2 80                    |        |		ADD.L	D0,D1
000206fe 42 80                    |B       |		CLR.L	D0
00020700 10 2e fc 1b              | .      |		MOVE.B	(A6-0x3e5),D0
00020704 52 40                    |R@      |		ADDQ.W	#0x1,D0
00020706 e2 40                    | @      |		ASR.W	#0x1,D0
00020708 48 c0                    |H       |		EXTW.L	D0
0002070a d0 81                    |        |		ADD.L	D1,D0
0002070c b0 84                    |        |		CMP.L	D4,D0
0002070e 63 02                    |c       |		BLS	0x20712
00020710 4e 4f                    |NO      |		TRAP	#15
00020712 3d 40 ff fc              |=@      |		MOVE.W	D0,(A6-0x4)
00020716 30 39 00 01 00 0c        |09      |		MOVE.W	0x1000c,D0
0002071c c0 ee fc 1c              |        |		MULU.W	(A6-0x3e4),D0
00020720 42 81                    |B       |		CLR.L	D1
00020722 12 2e fc 1e              | .      |		MOVE.B	(A6-0x3e2),D1
00020726 c2 f9 00 01 00 0a        |        |		MULU.W	0x1000a,D1
0002072c d2 80                    |        |		ADD.L	D0,D1
0002072e 42 80                    |B       |		CLR.L	D0
00020730 10 2e fc 1f              | .      |		MOVE.B	(A6-0x3e1),D0
00020734 53 40                    |S@      |		SUBQ.W	#0x1,D0
00020736 48 c0                    |H       |		EXTW.L	D0
00020738 81 fc 00 02              |        |		DIVS.W	#0x2,D0
0002073c 48 c0                    |H       |		EXTW.L	D0
0002073e d0 81                    |        |		ADD.L	D1,D0
00020740 b0 84                    |        |		CMP.L	D4,D0
00020742 63 02                    |c       |		BLS	0x20746
00020744 4e 4f                    |NO      |		TRAP	#15
00020746 3d 40 ff fe              |=@      |		MOVE.W	D0,(A6-0x2)
0002074a 7e 01                    |~       |		MOVEQ.L	#0x01,D7
0002074c be 6e ff fc              | n      |		CMP.W	(A6-0x4),D7
00020750 64 2a                    |d*      |		BCC	0x2077c
00020752 20 52                    | R      |		MOVEA.L	(A2),A0
00020754 42 80                    |B       |		CLR.L	D0
00020756 30 07                    |0       |		MOVE.W	D7,D0
00020758 22 00                    |"       |		MOVE.L	D0,D1
0002075a e4 99                    |        |		ROR.L	#0x2,D1
0002075c d0 c1                    |        |		ADDA.W	D1,A0
0002075e 48 41                    |HA      |		SWAP.W	D1
00020760 e7 59                    | Y      |		ROL.W	#0x3,D1
00020762 74 40                    |t@      |		MOVEQ.L	#0x40,D2
00020764 36 3c ff 3f              |6< ?    |		MOVE.W	#0xff3f,D3
00020768 e2 7b                    | {      |		ROR.W	D1,D3
0002076a c7 10                    |        |		AND.B	D3,(A0)
0002076c e2 2a                    | *      |		LSR.B	D1,D2
0002076e 85 10                    |        |		OR.B	D2,(A0)
00020770 52 80                    |R       |		ADDQ.L	#0x1,D0
00020772 b0 84                    |        |		CMP.L	D4,D0
00020774 63 02                    |c       |		BLS	0x20778
00020776 4e 4f                    |NO      |		TRAP	#15
00020778 3e 00                    |>       |		MOVE.W	D0,D7
0002077a 60 d0                    |`       |		BRA	0x2074c
0002077c 3e 04                    |>       |		MOVE.W	D4,D7
0002077e be 6e ff fe              | n      |		CMP.W	(A6-0x2),D7
00020782 63 2a                    |c*      |		BLS	0x207ae
00020784 20 52                    | R      |		MOVEA.L	(A2),A0
00020786 42 80                    |B       |		CLR.L	D0
00020788 30 07                    |0       |		MOVE.W	D7,D0
0002078a 22 00                    |"       |		MOVE.L	D0,D1
0002078c e4 99                    |        |		ROR.L	#0x2,D1
0002078e d0 c1                    |        |		ADDA.W	D1,A0
00020790 48 41                    |HA      |		SWAP.W	D1
00020792 e7 59                    | Y      |		ROL.W	#0x3,D1
00020794 74 40                    |t@      |		MOVEQ.L	#0x40,D2
00020796 36 3c ff 3f              |6< ?    |		MOVE.W	#0xff3f,D3
0002079a e2 7b                    | {      |		ROR.W	D1,D3
0002079c c7 10                    |        |		AND.B	D3,(A0)
0002079e e2 2a                    | *      |		LSR.B	D1,D2
000207a0 85 10                    |        |		OR.B	D2,(A0)
000207a2 53 80                    |S       |		SUBQ.L	#0x1,D0
000207a4 b0 84                    |        |		CMP.L	D4,D0
000207a6 63 02                    |c       |		BLS	0x207aa
000207a8 4e 4f                    |NO      |		TRAP	#15
000207aa 3e 00                    |>       |		MOVE.W	D0,D7
000207ac 60 d0                    |`       |		BRA	0x2077e
000207ae 4c df 0f ff              |L       |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D5+D6+D7+A0+A1+A2+A3
000207b2 4e 5e                    |N^      |		UNLK	A6
000207b4 4e 75                    |Nu      |		RTS
000207b6 ; --------------------------------------------------------------------------------------
000207b6 ; OMSI PASCAL Function
000207b6 ;    <LVAR  0x010 2(r)>
000207b6 ;    <LVAR  0x00e 2(r)>
000207b6 ;    <LVAR  0x00c 2(r)>
000207b6 ;    <LVAR  0x008 4(r)>
000207b6 ; --------------------------------------------------------------------------------------
000207b6 4e 56 ff 4e              |NV N    |		LINK.W	A6,#0xff4e
000207ba bf d5                    |        |		CMPA.L	(A5),A7
000207bc 62 06                    |b       |		BHI	0x207c4
000207be 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
000207c2 4e 76                    |Nv      |		TRAPV
000207c4 de fc 00 b0              |        |		ADDA.W	#0xb0,A7
000207c8 48 e7 fd f8              |H       |		MOVEM.L	A4+A3+A2+A1+A0+D7+D5+D4+D3+D2+D1+D0,-(A7)
000207cc 47 f9 00 01 02 c4        |G       |		LEA.L	StringLit(Src : Pointer; Offset: W; Len : W) : String,A3
000207d2 49 f9 00 02 54 74        |I   Tt  |		LEA.L	0x25474,A4
000207d8 78 14                    |x       |		MOVEQ.L	#0x14,D4
000207da 7a 01                    |z       |		MOVEQ.L	#0x01,D5
000207dc 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
000207e0 42 10                    |B       |		CLR.B	(A0)
000207e2 3e 2e 00 0e              |>.      |		MOVE.W	(A6+0xe),D7
000207e6 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
000207ea 42 80                    |B       |		CLR.L	D0
000207ec 30 2e 00 0e              |0.      |		MOVE.W	(A6+0xe),D0
000207f0 42 81                    |B       |		CLR.L	D1
000207f2 32 2e 00 0c              |2.      |		MOVE.W	(A6+0xc),D1
000207f6 d2 80                    |        |		ADD.L	D0,D1
000207f8 42 80                    |B       |		CLR.L	D0
000207fa 30 07                    |0       |		MOVE.W	D7,D0
000207fc b0 81                    |        |		CMP.L	D1,D0
000207fe 64 00 00 fe              |d       |		BCC	0x208fe
00020802 4a 10                    |J       |		TST.B	(A0)
00020804 66 00 00 f8              |f       |		BNE	0x208fe
00020808 22 54                    |"T      |		MOVEA.L	(A4),A1
0002080a 22 00                    |"       |		MOVE.L	D0,D1
0002080c e4 99                    |        |		ROR.L	#0x2,D1
0002080e d2 c1                    |        |		ADDA.W	D1,A1
00020810 48 41                    |HA      |		SWAP.W	D1
00020812 e7 59                    | Y      |		ROL.W	#0x3,D1
00020814 14 11                    |        |		MOVE.B	(A1),D2
00020816 e3 2a                    | *      |		LSL.B	D1,D2
00020818 ec 0a                    |        |		LSR.B	#0x6,D2
0002081a 66 1a                    |f       |		BNE	0x20836
0002081c 34 2e 00 10              |4.      |		MOVE.W	(A6+0x10),D2
00020820 36 3c ff 3f              |6< ?    |		MOVE.W	#0xff3f,D3
00020824 e2 7b                    | {      |		ROR.W	D1,D3
00020826 c7 11                    |        |		AND.B	D3,(A1)
00020828 02 02 00 03              |        |		ANDI.B	#0x03,D2
0002082c ed 0a                    |        |		LSL.B	#0x6,D2
0002082e e2 2a                    | *      |		LSR.B	D1,D2
00020830 85 11                    |        |		OR.B	D2,(A1)
00020832 60 00 00 b8              |`       |		BRA	0x208ec
00020836 72 14                    |r       |		MOVEQ.L	#0x14,D1
00020838 c3 ee 00 10              |        |		MULS.W	(A6+0x10),D1
0002083c 43 fa fb f2              |C       |		LEA.L	0x20430,A1
00020840 9e c4                    |        |		SUBA.W	D4,A7
00020842 24 4f                    |$O      |		MOVEA.L	A7,A2
00020844 43 f1 10 00              |C       |		LEA.L	(A1+D1.W),A1
00020848 72 13                    |r       |		MOVEQ.L	#0x13,D1
0002084a 14 d9                    |        |		MOVE.B	(A1)+,(A2)+
0002084c 51 c9 ff fc              |Q       |		DBF	D1,0x2084a
00020850 9e fc 00 22              |   "    |		SUBA.W	#0x22,A7
00020854 22 4f                    |"O      |		MOVEA.L	A7,A1
00020856 45 fa f9 88              |E       |		LEA.L	0x201e0,A2
0002085a 72 20                    |r       |		MOVEQ.L	#0x20,D1
0002085c 12 da                    |        |		MOVE.B	(A2)+,(A1)+
0002085e 51 c9 ff fc              |Q       |		DBF	D1,0x2085c
00020862 22 54                    |"T      |		MOVEA.L	(A4),A1
00020864 22 00                    |"       |		MOVE.L	D0,D1
00020866 e4 99                    |        |		ROR.L	#0x2,D1
00020868 d2 c1                    |        |		ADDA.W	D1,A1
0002086a 48 41                    |HA      |		SWAP.W	D1
0002086c e7 59                    | Y      |		ROL.W	#0x3,D1
0002086e 42 82                    |B       |		CLR.L	D2
00020870 14 11                    |        |		MOVE.B	(A1),D2
00020872 e3 2a                    | *      |		LSL.B	D1,D2
00020874 ec 0a                    |        |		LSR.B	#0x6,D2
00020876 c4 c4                    |        |		MULU.W	D4,D2
00020878 42 81                    |B       |		CLR.L	D1
0002087a 32 02                    |2       |		MOVE.W	D2,D1
0002087c 43 fa fb b2              |C       |		LEA.L	0x20430,A1
00020880 9e c4                    |        |		SUBA.W	D4,A7
00020882 24 4f                    |$O      |		MOVEA.L	A7,A2
00020884 43 f1 18 00              |C       |		LEA.L	(A1+D1.L),A1
00020888 72 13                    |r       |		MOVEQ.L	#0x13,D1
0002088a 14 d9                    |        |		MOVE.B	(A1)+,(A2)+
0002088c 51 c9 ff fc              |Q       |		DBF	D1,0x2088a
00020890 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00020892 22 4f                    |"O      |		MOVEA.L	A7,A1
00020894 45 fa f9 6c              |E  l    |		LEA.L	0x20202,A2
00020898 72 06                    |r       |		MOVEQ.L	#0x06,D1
0002089a 12 da                    |        |		MOVE.B	(A2)+,(A1)+
0002089c 51 c9 ff fc              |Q       |		DBF	D1,0x2089a
000208a0 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000208a2 48 6f 00 46              |Ho F    |		PEA.L	(A7+0x46)
000208a6 3f 05                    |?       |		MOVE.W	D5,-(A7)
000208a8 3f 04                    |?       |		MOVE.W	D4,-(A7)
000208aa 4e 93                    |N       |		JSR	(A3)
000208ac 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000208ae 48 6f 00 28              |Ho (    |		PEA.L	(A7+0x28)
000208b2 3f 05                    |?       |		MOVE.W	D5,-(A7)
000208b4 3f 3c 00 21              |?< !    |		MOVE.W	#0x21,-(A7)
000208b8 4e 93                    |N       |		JSR	(A3)
000208ba 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000208bc 48 6f 00 18              |Ho      |		PEA.L	(A7+0x18)
000208c0 3f 05                    |?       |		MOVE.W	D5,-(A7)
000208c2 3f 04                    |?       |		MOVE.W	D4,-(A7)
000208c4 4e 93                    |N       |		JSR	(A3)
000208c6 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000208c8 48 6f 00 14              |Ho      |		PEA.L	(A7+0x14)
000208cc 3f 05                    |?       |		MOVE.W	D5,-(A7)
000208ce 3f 3c 00 07              |?<      |		MOVE.W	#0x7,-(A7)
000208d2 4e 93                    |N       |		JSR	(A3)
000208d4 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000208d6 4e b9 00 01 02 d8        |N       |		JSR	StringCat4(a, b, c, d : String) : String
000208dc de fc 00 10              |        |		ADDA.W	#0x10,A7
000208e0 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
000208e6 de fc 00 56              |   V    |		ADDA.W	#0x56,A7
000208ea 10 85                    |        |		MOVE.B	D5,(A0)
000208ec 52 80                    |R       |		ADDQ.L	#0x1,D0
000208ee 0c 80 00 00 ff ff        |        |		CMPI.L	#0x0000ffff,D0
000208f4 63 02                    |c       |		BLS	0x208f8
000208f6 4e 4f                    |NO      |		TRAP	#15
000208f8 3e 00                    |>       |		MOVE.W	D0,D7
000208fa 60 00 fe ea              |`       |		BRA	0x207e6
000208fe 4c df 1f bf              |L       |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D5+D7+A0+A1+A2+A3+A4
00020902 4e 5e                    |N^      |		UNLK	A6
00020904 4e 75                    |Nu      |		RTS
00020906 ; --------------------------------------------------------------------------------------
00020906 ; OMSI PASCAL Function
00020906 ;    <LVAR  0x010 4(r)>
00020906 ;    <LVAR  0x00c 4(r)>
00020906 ;    <LVAR  0x008 4(r)>
00020906 ;    <LVAR -0x003 @ 1(r)>
00020906 ;    <LVAR -0x004 @ 1(r)>
00020906 ;    <LVAR -0x408 2(r)>
00020906 ;    <LVAR -0x40a @ 2(r)>
00020906 ; --------------------------------------------------------------------------------------
00020906 4e 56 fb 94              |NV      |		LINK.W	A6,#0xfb94
0002090a bf d5                    |        |		CMPA.L	(A5),A7
0002090c 62 06                    |b       |		BHI	0x20914
0002090e 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
00020912 4e 76                    |Nv      |		TRAPV
00020914 de fc 00 60              |   `    |		ADDA.W	#0x60,A7
00020918 48 e7 f9 f8              |H       |		MOVEM.L	A4+A3+A2+A1+A0+D7+D4+D3+D2+D1+D0,-(A7)
0002091c 45 f9 00 01 02 c4        |E       |		LEA.L	StringLit(Src : Pointer; Offset: W; Len : W) : String,A2
00020922 47 ee fb f6              |G       |		LEA.L	(A6-0x40a),A3
00020926 74 01                    |t       |		MOVEQ.L	#0x01,D2
00020928 76 0e                    |v       |		MOVEQ.L	#0x0e,D3
0002092a 78 24                    |x$      |		MOVEQ.L	#0x24,D4
0002092c 41 fa f9 2c              |A  ,    |		LEA.L	0x2025a,A0
00020930 70 08                    |p       |		MOVEQ.L	#0x08,D0
00020932 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
00020934 51 c8 ff fc              |Q       |		DBF	D0,0x20932
00020938 59 4f                    |YO      |		SUBQ.L	#0x4,A7
0002093a 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
0002093e 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020940 3f 3c 00 12              |?<      |		MOVE.W	#0x12,-(A7)
00020944 4e 92                    |N       |		JSR	(A2)
00020946 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020948 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
0002094e de fc 00 16              |        |		ADDA.W	#0x16,A7
00020952 20 6e 00 0c              | n      |		MOVEA.L	(A6+0xc),A0
00020956 42 50                    |BP      |		CLR.W	(A0)
00020958 20 6e 00 10              | n      |		MOVEA.L	(A6+0x10),A0
0002095c 42 50                    |BP      |		CLR.W	(A0)
0002095e 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
00020962 42 50                    |BP      |		CLR.W	(A0)
00020964 20 4b                    | K      |		MOVEA.L	A3,A0
00020966 2f 08                    |/       |		MOVE.L	A0,-(A7)
00020968 28 5f                    |(_      |		MOVEA.L	(A7)+,A4
0002096a 3e 39 00 01 00 10        |>9      |		MOVE.W	0x10010,D7
00020970 4a 47                    |JG      |		TST.W	D7
00020972 67 00 00 fc              |g       |		BEQ	0x20a70
00020976 20 6e 00 0c              | n      |		MOVEA.L	(A6+0xc),A0
0002097a 42 80                    |B       |		CLR.L	D0
0002097c 30 10                    |0       |		MOVE.W	(A0),D0
0002097e 52 80                    |R       |		ADDQ.L	#0x1,D0
00020980 0c 80 00 00 ff ff        |        |		CMPI.L	#0x0000ffff,D0
00020986 63 02                    |c       |		BLS	0x2098a
00020988 4e 4f                    |NO      |		TRAP	#15
0002098a 30 80                    |0       |		MOVE.W	D0,(A0)
0002098c 1f 3c 00 02              | <      |		MOVE.B	#0x02,-(A7)
00020990 3f 07                    |?       |		MOVE.W	D7,-(A7)
00020992 48 78 00 01              |Hx      |		PEA.L	0x1
00020996 2f 0c                    |/       |		MOVE.L	A4,-(A7)
00020998 48 6e ff fc              |Hn      |		PEA.L	(A6-0x4)
0002099c 4e b9 00 01 03 6c        |N    l  |		JSR	RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
000209a2 de fc 00 10              |        |		ADDA.W	#0x10,A7
000209a6 4a 2e ff fc              |J.      |		TST.B	(A6-0x4)
000209aa 66 2c                    |f,      |		BNE	0x209d8
000209ac 9e fc 00 1e              |        |		SUBA.W	#0x1e,A7
000209b0 20 4f                    | O      |		MOVEA.L	A7,A0
000209b2 43 fa f8 56              |C  V    |		LEA.L	0x2020a,A1
000209b6 70 1c                    |p       |		MOVEQ.L	#0x1c,D0
000209b8 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000209ba 51 c8 ff fc              |Q       |		DBF	D0,0x209b8
000209be 1f 03                    |        |		MOVE.B	D3,-(A7)
000209c0 59 4f                    |YO      |		SUBQ.L	#0x4,A7
000209c2 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
000209c6 3f 02                    |?       |		MOVE.W	D2,-(A7)
000209c8 3f 3c 00 1d              |?<      |		MOVE.W	#0x1d,-(A7)
000209cc 4e 92                    |N       |		JSR	(A2)
000209ce 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000209d0 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
000209d6 de c4                    |        |		ADDA.W	D4,A7
000209d8 4a 53                    |JS      |		TST.W	(A3)
000209da 66 28                    |f(      |		BNE	0x20a04
000209dc 41 fa f8 6a              |A  j    |		LEA.L	0x20248,A0
000209e0 70 07                    |p       |		MOVEQ.L	#0x07,D0
000209e2 2f 20                    |/       |		MOVE.L	-(A0),-(A7)
000209e4 51 c8 ff fc              |Q       |		DBF	D0,0x209e2
000209e8 1f 03                    |        |		MOVE.B	D3,-(A7)
000209ea 59 4f                    |YO      |		SUBQ.L	#0x4,A7
000209ec 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
000209f0 3f 02                    |?       |		MOVE.W	D2,-(A7)
000209f2 3f 3c 00 20              |?<      |		MOVE.W	#0x20,-(A7)
000209f6 4e 92                    |N       |		JSR	(A2)
000209f8 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000209fa 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
00020a00 de fc 00 26              |   &    |		ADDA.W	#0x26,A7
00020a04 20 6e 00 10              | n      |		MOVEA.L	(A6+0x10),A0
00020a08 42 80                    |B       |		CLR.L	D0
00020a0a 30 10                    |0       |		MOVE.W	(A0),D0
00020a0c 42 81                    |B       |		CLR.L	D1
00020a0e 32 13                    |2       |		MOVE.W	(A3),D1
00020a10 d0 81                    |        |		ADD.L	D1,D0
00020a12 0c 80 00 00 ff ff        |        |		CMPI.L	#0x0000ffff,D0
00020a18 63 02                    |c       |		BLS	0x20a1c
00020a1a 4e 4f                    |NO      |		TRAP	#15
00020a1c 30 80                    |0       |		MOVE.W	D0,(A0)
00020a1e 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
00020a22 b2 50                    | P      |		CMP.W	(A0),D1
00020a24 63 02                    |c       |		BLS	0x20a28
00020a26 30 81                    |0       |		MOVE.W	D1,(A0)
00020a28 3f 3c 00 03              |?<      |		MOVE.W	#0x3,-(A7)
00020a2c 3f 07                    |?       |		MOVE.W	D7,-(A7)
00020a2e 3f 13                    |?       |		MOVE.W	(A3),-(A7)
00020a30 48 6e ff fd              |Hn      |		PEA.L	(A6-0x3)
00020a34 4e ba fd 80              |N       |		JSR	0x207b6
00020a38 de fc 00 0a              |        |		ADDA.W	#0xa,A7
00020a3c 4a 2e ff fd              |J.      |		TST.B	(A6-0x3)
00020a40 67 26                    |g&      |		BEQ	0x20a68
00020a42 41 fa f8 3a              |A  :    |		LEA.L	0x2027e,A0
00020a46 70 08                    |p       |		MOVEQ.L	#0x08,D0
00020a48 2f 20                    |/       |		MOVE.L	-(A0),-(A7)
00020a4a 51 c8 ff fc              |Q       |		DBF	D0,0x20a48
00020a4e 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020a50 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
00020a54 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020a56 3f 04                    |?       |		MOVE.W	D4,-(A7)
00020a58 4e 92                    |N       |		JSR	(A2)
00020a5a 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020a5c 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
00020a62 de fc 00 28              |   (    |		ADDA.W	#0x28,A7
00020a66 60 08                    |`       |		BRA	0x20a70
00020a68 3e 2e fb f8              |>.      |		MOVE.W	(A6-0x408),D7
00020a6c 60 00 ff 02              |`       |		BRA	0x20970
00020a70 4c df 1f 9f              |L       |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D7+A0+A1+A2+A3+A4
00020a74 4e 5e                    |N^      |		UNLK	A6
00020a76 4e 75                    |Nu      |		RTS
00020a78 ; --------------------------------------------------------------------------------------
00020a78 ; OMSI PASCAL Function
00020a78 ;    <LVAR  0x008 4(r)>
00020a78 ;    <LVAR -0x004 4(rw)>
00020a78 ;    <LVAR -0x00b @ 1(r)>
00020a78 ;    <LVAR -0x00c @ 1(r)>
00020a78 ;    <LVAR -0x010 4(rw)>
00020a78 ;    <LVAR -0x020 4(w)>
00020a78 ; --------------------------------------------------------------------------------------
00020a78 4e 56 ff 3c              |NV <    |		LINK.W	A6,#0xff3c
00020a7c bf d5                    |        |		CMPA.L	(A5),A7
00020a7e 62 06                    |b       |		BHI	0x20a86
00020a80 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
00020a84 4e 76                    |Nv      |		TRAPV
00020a86 de fc 00 a0              |        |		ADDA.W	#0xa0,A7
00020a8a 48 e7 ff f8              |H       |		MOVEM.L	A4+A3+A2+A1+A0+D7+D6+D5+D4+D3+D2+D1+D0,-(A7)
00020a8e 45 f9 00 01 02 c4        |E       |		LEA.L	StringLit(Src : Pointer; Offset: W; Len : W) : String,A2
00020a94 47 ee ff f0              |G       |		LEA.L	(A6-0x10),A3
00020a98 49 f9 00 01 03 e0        |I       |		LEA.L	WriteConsoleStringCrLf(str : String),A4
00020a9e 9e fc 00 14              |        |		SUBA.W	#0x14,A7
00020aa2 20 4f                    | O      |		MOVEA.L	A7,A0
00020aa4 43 fa f7 ee              |C       |		LEA.L	0x20294,A1
00020aa8 70 12                    |p       |		MOVEQ.L	#0x12,D0
00020aaa 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020aac 51 c8 ff fc              |Q       |		DBF	D0,0x20aaa
00020ab0 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020ab2 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
00020ab6 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020aba 3f 3c 00 13              |?<      |		MOVE.W	#0x13,-(A7)
00020abe 4e 92                    |N       |		JSR	(A2)
00020ac0 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020ac2 4e 94                    |N       |		JSR	(A4)
00020ac4 de fc 00 18              |        |		ADDA.W	#0x18,A7
00020ac8 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
00020acc 42 90                    |B       |		CLR.L	(A0)
00020ace 42 ae ff fc              |B       |		CLR.L	(A6-0x4)
00020ad2 70 00                    |p       |		MOVEQ.L	#0x00,D0
00020ad4 2f 00                    |/       |		MOVE.L	D0,-(A7)
00020ad6 22 00                    |"       |		MOVE.L	D0,D1
00020ad8 e5 81                    |        |		ASL.L	#0x2,D1
00020ada 28 01                    |(       |		MOVE.L	D1,D4
00020adc 26 3c 00 00 01 00        |&<      |		MOVE.L	#0x100,D3
00020ae2 4e b9 00 01 02 94        |N       |		JSR	?divs_d3_d4
00020ae8 2f 03                    |/       |		MOVE.L	D3,-(A7)
00020aea 28 00                    |(       |		MOVE.L	D0,D4
00020aec 76 40                    |v@      |		MOVEQ.L	#0x40,D3
00020aee 4e b9 00 01 02 94        |N       |		JSR	?divs_d3_d4
00020af4 0c 84 00 00 00 07        |        |		CMPI.L	#0x00000007,D4
00020afa 63 02                    |c       |		BLS	0x20afe
00020afc 4e 4f                    |NO      |		TRAP	#15
00020afe e3 84                    |        |		ASL.L	#0x1,D4
00020b00 41 f8 00 00              |A       |		LEA.L	0x0,A0
00020b04 41 f0 48 00              |A H     |		LEA.L	(A0+D4.L),A0
00020b08 d1 fc 00 01 00 12        |        |		ADDA.L	#0x10012,A0
00020b0e 42 81                    |B       |		CLR.L	D1
00020b10 32 10                    |2       |		MOVE.W	(A0),D1
00020b12 24 1f                    |$       |		MOVE.L	(A7)+,D2
00020b14 d4 81                    |        |		ADD.L	D1,D2
00020b16 2d 42 ff e0              |-B      |		MOVE.L	D2,(A6-0x20)
00020b1a 1f 3c 00 02              | <      |		MOVE.B	#0x02,-(A7)
00020b1e 0c 82 00 00 ff ff        |        |		CMPI.L	#0x0000ffff,D2
00020b24 63 02                    |c       |		BLS	0x20b28
00020b26 4e 4f                    |NO      |		TRAP	#15
00020b28 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020b2a 48 78 00 04              |Hx      |		PEA.L	0x4
00020b2e 2f 39 00 02 64 be        |/9  d   |		MOVE.L	0x264be,-(A7)
00020b34 48 6e ff f4              |Hn      |		PEA.L	(A6-0xc)
00020b38 4e b9 00 01 03 6c        |N    l  |		JSR	RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
00020b3e de fc 00 10              |        |		ADDA.W	#0x10,A7
00020b42 4a 2e ff f4              |J.      |		TST.B	(A6-0xc)
00020b46 66 32                    |f2      |		BNE	0x20b7a
00020b48 9e fc 00 16              |        |		SUBA.W	#0x16,A7
00020b4c 20 4f                    | O      |		MOVEA.L	A7,A0
00020b4e 43 fa f7 2e              |C  .    |		LEA.L	0x2027e,A1
00020b52 72 14                    |r       |		MOVEQ.L	#0x14,D1
00020b54 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020b56 51 c9 ff fc              |Q       |		DBF	D1,0x20b54
00020b5a 1f 3c 00 0e              | <      |		MOVE.B	#0x0e,-(A7)
00020b5e 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020b60 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
00020b64 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020b68 3f 3c 00 15              |?<      |		MOVE.W	#0x15,-(A7)
00020b6c 4e 92                    |N       |		JSR	(A2)
00020b6e 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020b70 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
00020b76 de fc 00 1c              |        |		ADDA.W	#0x1c,A7
00020b7a 72 00                    |r       |		MOVEQ.L	#0x00,D1
00020b7c 2f 01                    |/       |		MOVE.L	D1,-(A7)
00020b7e 42 93                    |B       |		CLR.L	(A3)
00020b80 7a 00                    |z       |		MOVEQ.L	#0x00,D5
00020b82 20 17                    |        |		MOVE.L	(A7),D0
00020b84 0c 80 00 00 00 03        |        |		CMPI.L	#0x00000003,D0
00020b8a 63 02                    |c       |		BLS	0x20b8e
00020b8c 4e 4f                    |NO      |		TRAP	#15
00020b8e e1 80                    |        |		ASL.L	#0x8,D0
00020b90 e5 80                    |        |		ASL.L	#0x2,D0
00020b92 41 f9 00 02 14 6c        |A    l  |		LEA.L	0x2146c,A0
00020b98 0c 85 00 00 00 0f        |        |		CMPI.L	#0x0000000f,D5
00020b9e 63 02                    |c       |		BLS	0x20ba2
00020ba0 4e 4f                    |NO      |		TRAP	#15
00020ba2 22 05                    |"       |		MOVE.L	D5,D1
00020ba4 ed 81                    |        |		ASL.L	#0x6,D1
00020ba6 41 f0 08 00              |A       |		LEA.L	(A0+D0.L),A0
00020baa 2f 08                    |/       |		MOVE.L	A0,-(A7)
00020bac 0c 85 00 00 00 10        |        |		CMPI.L	#0x00000010,D5
00020bb2 6c 00 01 2e              |l  .    |		BGE	0x20ce2
00020bb6 41 f0 18 00              |A       |		LEA.L	(A0+D1.L),A0
00020bba 10 28 40 4b              | (@K    |		MOVE.B	(A0+0x404b),D0
00020bbe e9 08                    |        |		LSL.B	#0x4,D0
00020bc0 ee 08                    |        |		LSR.B	#0x7,D0
00020bc2 66 00 01 1e              |f       |		BNE	0x20ce2
00020bc6 52 93                    |R       |		ADDQ.L	#0x1,(A3)
00020bc8 20 57                    | W      |		MOVEA.L	(A7),A0
00020bca 41 f0 18 00              |A       |		LEA.L	(A0+D1.L),A0
00020bce 2f 08                    |/       |		MOVE.L	A0,-(A7)
00020bd0 7e 00                    |~       |		MOVEQ.L	#0x00,D7
00020bd2 7c 00                    ||       |		MOVEQ.L	#0x00,D6
00020bd4 70 00                    |p       |		MOVEQ.L	#0x00,D0
00020bd6 0c 80 00 00 00 05        |        |		CMPI.L	#0x00000005,D0
00020bdc 63 02                    |c       |		BLS	0x20be0
00020bde 4e 4f                    |NO      |		TRAP	#15
00020be0 22 00                    |"       |		MOVE.L	D0,D1
00020be2 e5 81                    |        |		ASL.L	#0x2,D1
00020be4 20 57                    | W      |		MOVEA.L	(A7),A0
00020be6 41 e8 40 0c              |A @     |		LEA.L	(A0+0x400c),A0
00020bea 4a 70 18 22              |Jp "    |		TST.W	(A0+D1.L+#0x22)
00020bee 67 36                    |g6      |		BEQ	0x20c26
00020bf0 3f 3c 00 02              |?<      |		MOVE.W	#0x2,-(A7)
00020bf4 3f 30 18 24              |?0 $    |		MOVE.W	(A0+D1.L+#0x24),-(A7)
00020bf8 34 30 18 22              |40 "    |		MOVE.W	(A0+D1.L+#0x22),D2
00020bfc 48 c2                    |H       |		EXTW.L	D2
00020bfe 94 87                    |        |		SUB.L	D7,D2
00020c00 0c 82 00 00 ff ff        |        |		CMPI.L	#0x0000ffff,D2
00020c06 63 02                    |c       |		BLS	0x20c0a
00020c08 4e 4f                    |NO      |		TRAP	#15
00020c0a 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020c0c 48 6e ff f5              |Hn      |		PEA.L	(A6-0xb)
00020c10 4e ba fb a4              |N       |		JSR	0x207b6
00020c14 de fc 00 0a              |        |		ADDA.W	#0xa,A7
00020c18 34 30 18 22              |40 "    |		MOVE.W	(A0+D1.L+#0x22),D2
00020c1c 48 c2                    |H       |		EXTW.L	D2
00020c1e 2e 02                    |.       |		MOVE.L	D2,D7
00020c20 4a 80                    |J       |		TST.L	D0
00020c22 6f 02                    |o       |		BLE	0x20c26
00020c24 7c 01                    ||       |		MOVEQ.L	#0x01,D6
00020c26 52 80                    |R       |		ADDQ.L	#0x1,D0
00020c28 0c 80 00 00 00 05        |        |		CMPI.L	#0x00000005,D0
00020c2e 6f a6                    |o       |		BLE	0x20bd6
00020c30 4a 06                    |J       |		TST.B	D6
00020c32 67 52                    |gR      |		BEQ	0x20c86
00020c34 9e fc 00 1a              |        |		SUBA.W	#0x1a,A7
00020c38 20 4f                    | O      |		MOVEA.L	A7,A0
00020c3a 43 fa f6 6c              |C  l    |		LEA.L	0x202a8,A1
00020c3e 70 18                    |p       |		MOVEQ.L	#0x18,D0
00020c40 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020c42 51 c8 ff fc              |Q       |		DBF	D0,0x20c40
00020c46 20 6f 00 1a              | o      |		MOVEA.L	(A7+0x1a),A0
00020c4a 41 e8 40 2a              |A @*    |		LEA.L	(A0+0x402a),A0
00020c4e 70 0e                    |p       |		MOVEQ.L	#0x0e,D0
00020c50 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
00020c52 51 c8 ff fc              |Q       |		DBF	D0,0x20c50
00020c56 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00020c58 48 6f 00 26              |Ho &    |		PEA.L	(A7+0x26)
00020c5c 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020c60 3f 3c 00 19              |?<      |		MOVE.W	#0x19,-(A7)
00020c64 4e 92                    |N       |		JSR	(A2)
00020c66 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020c68 48 6f 00 0c              |Ho      |		PEA.L	(A7+0xc)
00020c6c 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020c70 3f 3c 00 1e              |?<      |		MOVE.W	#0x1e,-(A7)
00020c74 4e 92                    |N       |		JSR	(A2)
00020c76 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020c78 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
00020c7e 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020c80 4e 94                    |N       |		JSR	(A4)
00020c82 de fc 00 3c              |   <    |		ADDA.W	#0x3c,A7
00020c86 4a 2e ff f5              |J.      |		TST.B	(A6-0xb)
00020c8a 67 4c                    |gL      |		BEQ	0x20cd8
00020c8c 41 fa f6 4c              |A  L    |		LEA.L	0x202da,A0
00020c90 70 05                    |p       |		MOVEQ.L	#0x05,D0
00020c92 2f 20                    |/       |		MOVE.L	-(A0),-(A7)
00020c94 51 c8 ff fc              |Q       |		DBF	D0,0x20c92
00020c98 20 6f 00 18              | o      |		MOVEA.L	(A7+0x18),A0
00020c9c 41 e8 40 2a              |A @*    |		LEA.L	(A0+0x402a),A0
00020ca0 70 0e                    |p       |		MOVEQ.L	#0x0e,D0
00020ca2 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
00020ca4 51 c8 ff fc              |Q       |		DBF	D0,0x20ca2
00020ca8 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00020caa 48 6f 00 26              |Ho &    |		PEA.L	(A7+0x26)
00020cae 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020cb2 3f 3c 00 18              |?<      |		MOVE.W	#0x18,-(A7)
00020cb6 4e 92                    |N       |		JSR	(A2)
00020cb8 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020cba 48 6f 00 0c              |Ho      |		PEA.L	(A7+0xc)
00020cbe 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020cc2 3f 3c 00 1e              |?<      |		MOVE.W	#0x1e,-(A7)
00020cc6 4e 92                    |N       |		JSR	(A2)
00020cc8 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020cca 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
00020cd0 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020cd2 4e 94                    |N       |		JSR	(A4)
00020cd4 de fc 00 3a              |   :    |		ADDA.W	#0x3a,A7
00020cd8 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020cda 52 85                    |R       |		ADDQ.L	#0x1,D5
00020cdc 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020cde 60 00 fe a2              |`       |		BRA	0x20b82
00020ce2 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020ce4 20 13                    |        |		MOVE.L	(A3),D0
00020ce6 b0 ae ff fc              |        |		CMP.L	(A6-0x4),D0
00020cea 6f 14                    |o       |		BLE	0x20d00
00020cec 2d 40 ff fc              |-@      |		MOVE.L	D0,(A6-0x4)
00020cf0 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
00020cf4 20 2f 00 04              | /      |		MOVE.L	(A7+0x4),D0
00020cf8 e5 80                    |        |		ASL.L	#0x2,D0
00020cfa 22 17                    |"       |		MOVE.L	(A7),D1
00020cfc d2 80                    |        |		ADD.L	D0,D1
00020cfe 20 81                    |        |		MOVE.L	D1,(A0)
00020d00 20 13                    |        |		MOVE.L	(A3),D0
00020d02 0c 80 00 00 00 10        |        |		CMPI.L	#0x00000010,D0
00020d08 63 02                    |c       |		BLS	0x20d0c
00020d0a 4e 4f                    |NO      |		TRAP	#15
00020d0c e5 80                    |        |		ASL.L	#0x2,D0
00020d0e 41 f9 00 02 14 6c        |A    l  |		LEA.L	0x2146c,A0
00020d14 41 f0 08 00              |A       |		LEA.L	(A0+D0.L),A0
00020d18 52 a8 50 0c              |R P     |		ADDQ.L	#0x1,(A0+0x500c)
00020d1c 22 17                    |"       |		MOVE.L	(A7),D1
00020d1e 52 81                    |R       |		ADDQ.L	#0x1,D1
00020d20 0c 81 00 00 00 03        |        |		CMPI.L	#0x00000003,D1
00020d26 6e 06                    |n       |		BGT	0x20d2e
00020d28 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020d2a 60 00 fe 50              |`  P    |		BRA	0x20b7c
00020d2e 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020d30 20 17                    |        |		MOVE.L	(A7),D0
00020d32 52 80                    |R       |		ADDQ.L	#0x1,D0
00020d34 0c 80 00 00 01 ff        |        |		CMPI.L	#0x000001ff,D0
00020d3a 6e 06                    |n       |		BGT	0x20d42
00020d3c 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020d3e 60 00 fd 94              |`       |		BRA	0x20ad4
00020d42 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020d44 4c df 1f ff              |L       |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D5+D6+D7+A0+A1+A2+A3+A4
00020d48 4e 5e                    |N^      |		UNLK	A6
00020d4a 4e 75                    |Nu      |		RTS
00020d4c ; --------------------------------------------------------------------------------------
00020d4c ; OMSI PASCAL Function
00020d4c ;    <LVAR  0x008 4(r)>
00020d4c ;    <LVAR -0x002 @>
00020d4c ;    <LVAR -0x402 @>
00020d4c ;    <LVAR -0x408 @>
00020d4c ; --------------------------------------------------------------------------------------
00020d4c 4e 56 fb 7a              |NV z    |		LINK.W	A6,#0xfb7a
00020d50 bf d5                    |        |		CMPA.L	(A5),A7
00020d52 62 06                    |b       |		BHI	0x20d5a
00020d54 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
00020d58 4e 76                    |Nv      |		TRAPV
00020d5a de fc 00 7e              |   ~    |		ADDA.W	#0x7e,A7
00020d5e 48 e7 ff e0              |H       |		MOVEM.L	A2+A1+A0+D7+D6+D5+D4+D3+D2+D1+D0,-(A7)
00020d62 45 f9 00 01 02 c4        |E       |		LEA.L	StringLit(Src : Pointer; Offset: W; Len : W) : String,A2
00020d68 74 01                    |t       |		MOVEQ.L	#0x01,D2
00020d6a 7a 0c                    |z       |		MOVEQ.L	#0x0c,D5
00020d6c 28 2e 00 08              |(.      |		MOVE.L	(A6+0x8),D4
00020d70 26 3c 00 00 01 00        |&<      |		MOVE.L	#0x100,D3
00020d76 4e b9 00 01 02 94        |N       |		JSR	?divs_d3_d4
00020d7c 0c 84 00 00 00 07        |        |		CMPI.L	#0x00000007,D4
00020d82 63 02                    |c       |		BLS	0x20d86
00020d84 4e 4f                    |NO      |		TRAP	#15
00020d86 e3 84                    |        |		ASL.L	#0x1,D4
00020d88 41 f8 00 00              |A       |		LEA.L	0x0,A0
00020d8c 41 f0 48 00              |A H     |		LEA.L	(A0+D4.L),A0
00020d90 d1 fc 00 01 00 12        |        |		ADDA.L	#0x10012,A0
00020d96 42 80                    |B       |		CLR.L	D0
00020d98 30 10                    |0       |		MOVE.W	(A0),D0
00020d9a d6 80                    |        |		ADD.L	D0,D3
00020d9c 0c 83 00 00 ff ff        |        |		CMPI.L	#0x0000ffff,D3
00020da2 63 02                    |c       |		BLS	0x20da6
00020da4 4e 4f                    |NO      |		TRAP	#15
00020da6 3c 03                    |<       |		MOVE.W	D3,D6
00020da8 1f 3c 00 02              | <      |		MOVE.B	#0x02,-(A7)
00020dac 3f 06                    |?       |		MOVE.W	D6,-(A7)
00020dae 48 78 00 01              |Hx      |		PEA.L	0x1
00020db2 41 ee fb fe              |A       |		LEA.L	(A6-0x402),A0
00020db6 2f 08                    |/       |		MOVE.L	A0,-(A7)
00020db8 48 6e ff fe              |Hn      |		PEA.L	(A6-0x2)
00020dbc 4e b9 00 01 03 6c        |N    l  |		JSR	RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
00020dc2 de c5                    |        |		ADDA.W	D5,A7
00020dc4 2e ba f5 20              |.       |		MOVE.L	0x202e6,(A7)
00020dc8 2f 3a f5 18              |/:      |		MOVE.L	0x202e2,-(A7)
00020dcc 2f 3a f5 10              |/:      |		MOVE.L	0x202de,-(A7)
00020dd0 2f 3a f5 08              |/:      |		MOVE.L	0x202da,-(A7)
00020dd4 9e fc 00 26              |   &    |		SUBA.W	#0x26,A7
00020dd8 20 4f                    | O      |		MOVEA.L	A7,A0
00020dda 43 fa f5 0e              |C       |		LEA.L	0x202ea,A1
00020dde 70 24                    |p$      |		MOVEQ.L	#0x24,D0
00020de0 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020de2 51 c8 ff fc              |Q       |		DBF	D0,0x20de0
00020de6 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00020de8 48 6f 00 2e              |Ho .    |		PEA.L	(A7+0x2e)
00020dec 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020dee 3f 3c 00 10              |?<      |		MOVE.W	#0x10,-(A7)
00020df2 4e 92                    |N       |		JSR	(A2)
00020df4 2e ae 00 08              |.       |		MOVE.L	(A6+0x8),(A7)
00020df8 4e b9 00 01 02 e4        |N       |		JSR	Long2String(a : Long) : String
00020dfe 48 6f 00 10              |Ho      |		PEA.L	(A7+0x10)
00020e02 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020e04 3f 3c 00 25              |?< %    |		MOVE.W	#0x25,-(A7)
00020e08 4e 92                    |N       |		JSR	(A2)
00020e0a 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020e0c 4e b9 00 01 02 d4        |N       |		JSR	StringCat3(a, b, c : String) : String
00020e12 de c5                    |        |		ADDA.W	D5,A7
00020e14 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
00020e1a de fc 00 3a              |   :    |		ADDA.W	#0x3a,A7
00020e1e 7e 00                    |~       |		MOVEQ.L	#0x00,D7
00020e20 0c 87 00 00 00 0f        |        |		CMPI.L	#0x0000000f,D7
00020e26 63 02                    |c       |		BLS	0x20e2a
00020e28 4e 4f                    |NO      |		TRAP	#15
00020e2a 20 07                    |        |		MOVE.L	D7,D0
00020e2c ed 80                    |        |		ASL.L	#0x6,D0
00020e2e 41 ee fb f8              |A       |		LEA.L	(A6-0x408),A0
00020e32 12 30 08 45              | 0 E    |		MOVE.B	(A0+D0.L+#0x45),D1
00020e36 e9 09                    |        |		LSL.B	#0x4,D1
00020e38 ee 09                    |        |		LSR.B	#0x7,D1
00020e3a 66 26                    |f&      |		BNE	0x20e62
00020e3c 41 f0 08 24              |A  $    |		LEA.L	(A0+D0.L+#0x24),A0
00020e40 70 0e                    |p       |		MOVEQ.L	#0x0e,D0
00020e42 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
00020e44 51 c8 ff fc              |Q       |		DBF	D0,0x20e42
00020e48 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020e4a 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
00020e4e 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020e50 3f 3c 00 1e              |?<      |		MOVE.W	#0x1e,-(A7)
00020e54 4e 92                    |N       |		JSR	(A2)
00020e56 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020e58 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
00020e5e de fc 00 22              |   "    |		ADDA.W	#0x22,A7
00020e62 52 87                    |R       |		ADDQ.L	#0x1,D7
00020e64 0c 87 00 00 00 0f        |        |		CMPI.L	#0x0000000f,D7
00020e6a 6f b4                    |o       |		BLE	0x20e20
00020e6c 4c df 07 ff              |L       |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D5+D6+D7+A0+A1+A2
00020e70 4e 5e                    |N^      |		UNLK	A6
00020e72 4e 75                    |Nu      |		RTS
00020e74 ; --------------------------------------------------------------------------------------
00020e74 ; OMSI PASCAL Function
00020e74 ;    <LVAR  0x010 4(r)>
00020e74 ;    <LVAR  0x00c 4(r)>
00020e74 ;    <LVAR  0x008 4(r)>
00020e74 ;    <LVAR -0x402 2(w)>
00020e74 ;    <LVAR -0x404 @ 2(w) 4(r)>
00020e74 ;    <LVAR -0x40a 2(rw)>
00020e74 ;    <LVAR -0x40b @ 1(r)>
00020e74 ; --------------------------------------------------------------------------------------
00020e74 4e 56 fb 6e              |NV n    |		LINK.W	A6,#0xfb6e
00020e78 bf d5                    |        |		CMPA.L	(A5),A7
00020e7a 62 06                    |b       |		BHI	0x20e82
00020e7c 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
00020e80 4e 76                    |Nv      |		TRAPV
00020e82 de fc 00 86              |        |		ADDA.W	#0x86,A7
00020e86 48 e7 ff f0              |H       |		MOVEM.L	A3+A2+A1+A0+D7+D6+D5+D4+D3+D2+D1+D0,-(A7)
00020e8a 45 ee fb f6              |E       |		LEA.L	(A6-0x40a),A2
00020e8e 47 ee fb fc              |G       |		LEA.L	(A6-0x404),A3
00020e92 26 3c 00 00 ff ff        |&<      |		MOVE.L	#0xffff,D3
00020e98 78 03                    |x       |		MOVEQ.L	#0x03,D4
00020e9a 20 6e 00 0c              | n      |		MOVEA.L	(A6+0xc),A0
00020e9e 42 50                    |BP      |		CLR.W	(A0)
00020ea0 20 6e 00 10              | n      |		MOVEA.L	(A6+0x10),A0
00020ea4 42 50                    |BP      |		CLR.W	(A0)
00020ea6 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
00020eaa 42 50                    |BP      |		CLR.W	(A0)
00020eac 7e 00                    |~       |		MOVEQ.L	#0x00,D7
00020eae 7a 00                    |z       |		MOVEQ.L	#0x00,D5
00020eb0 7c 00                    ||       |		MOVEQ.L	#0x00,D6
00020eb2 34 83                    |4       |		MOVE.W	D3,(A2)
00020eb4 20 79 00 02 54 74        | y  Tt  |		MOVEA.L	0x25474,A0
00020eba 42 80                    |B       |		CLR.L	D0
00020ebc 30 12                    |0       |		MOVE.W	(A2),D0
00020ebe 22 00                    |"       |		MOVE.L	D0,D1
00020ec0 e4 99                    |        |		ROR.L	#0x2,D1
00020ec2 d0 c1                    |        |		ADDA.W	D1,A0
00020ec4 48 41                    |HA      |		SWAP.W	D1
00020ec6 e7 59                    | Y      |		ROL.W	#0x3,D1
00020ec8 42 82                    |B       |		CLR.L	D2
00020eca 14 10                    |        |		MOVE.B	(A0),D2
00020ecc e3 2a                    | *      |		LSL.B	D1,D2
00020ece ec 0a                    |        |		LSR.B	#0x6,D2
00020ed0 b4 44                    | D      |		CMP.W	D4,D2
00020ed2 66 10                    |f       |		BNE	0x20ee4
00020ed4 42 81                    |B       |		CLR.L	D1
00020ed6 32 06                    |2       |		MOVE.W	D6,D1
00020ed8 52 81                    |R       |		ADDQ.L	#0x1,D1
00020eda b2 83                    |        |		CMP.L	D3,D1
00020edc 63 02                    |c       |		BLS	0x20ee0
00020ede 4e 4f                    |NO      |		TRAP	#15
00020ee0 3c 01                    |<       |		MOVE.W	D1,D6
00020ee2 7e 01                    |~       |		MOVEQ.L	#0x01,D7
00020ee4 b4 44                    | D      |		CMP.W	D4,D2
00020ee6 67 04                    |g       |		BEQ	0x20eec
00020ee8 4a 07                    |J       |		TST.B	D7
00020eea 66 08                    |f       |		BNE	0x20ef4
00020eec 0c 46 40 00              | F@     |		CMPI.W	#0x4000,D6
00020ef0 66 00 00 b0              |f       |		BNE	0x20fa2
00020ef4 20 6e 00 0c              | n      |		MOVEA.L	(A6+0xc),A0
00020ef8 42 81                    |B       |		CLR.L	D1
00020efa 32 10                    |2       |		MOVE.W	(A0),D1
00020efc 52 81                    |R       |		ADDQ.L	#0x1,D1
00020efe b2 83                    |        |		CMP.L	D3,D1
00020f00 63 02                    |c       |		BLS	0x20f04
00020f02 4e 4f                    |NO      |		TRAP	#15
00020f04 30 81                    |0       |		MOVE.W	D1,(A0)
00020f06 20 6e 00 10              | n      |		MOVEA.L	(A6+0x10),A0
00020f0a 42 81                    |B       |		CLR.L	D1
00020f0c 32 10                    |2       |		MOVE.W	(A0),D1
00020f0e 42 82                    |B       |		CLR.L	D2
00020f10 34 06                    |4       |		MOVE.W	D6,D2
00020f12 d2 82                    |        |		ADD.L	D2,D1
00020f14 b2 83                    |        |		CMP.L	D3,D1
00020f16 63 02                    |c       |		BLS	0x20f1a
00020f18 4e 4f                    |NO      |		TRAP	#15
00020f1a 30 81                    |0       |		MOVE.W	D1,(A0)
00020f1c 20 6e 00 08              | n      |		MOVEA.L	(A6+0x8),A0
00020f20 b4 50                    | P      |		CMP.W	(A0),D2
00020f22 63 02                    |c       |		BLS	0x20f26
00020f24 30 82                    |0       |		MOVE.W	D2,(A0)
00020f26 3d 45 fb fe              |=E      |		MOVE.W	D5,(A6-0x402)
00020f2a 36 82                    |6       |		MOVE.W	D2,(A3)
00020f2c 23 d3 00 01 00 22        |#    "  |		MOVE.L	(A3),0x10022
00020f32 0c 42 40 00              | B@     |		CMPI.W	#0x4000,D2
00020f36 66 04                    |f       |		BNE	0x20f3c
00020f38 3a 00                    |:       |		MOVE.W	D0,D5
00020f3a 60 0c                    |`       |		BRA	0x20f48
00020f3c 22 00                    |"       |		MOVE.L	D0,D1
00020f3e 52 81                    |R       |		ADDQ.L	#0x1,D1
00020f40 b2 83                    |        |		CMP.L	D3,D1
00020f42 63 02                    |c       |		BLS	0x20f46
00020f44 4e 4f                    |NO      |		TRAP	#15
00020f46 3a 01                    |:       |		MOVE.W	D1,D5
00020f48 1f 04                    |        |		MOVE.B	D4,-(A7)
00020f4a 3f 05                    |?       |		MOVE.W	D5,-(A7)
00020f4c 48 78 00 01              |Hx      |		PEA.L	0x1
00020f50 20 4b                    | K      |		MOVEA.L	A3,A0
00020f52 2f 08                    |/       |		MOVE.L	A0,-(A7)
00020f54 48 6e fb f5              |Hn      |		PEA.L	(A6-0x40b)
00020f58 4e b9 00 01 03 6c        |N    l  |		JSR	RW_Sectors(oper : B; lba : Word; cnt : L; ptr : Pointer; VAR status : B)
00020f5e de fc 00 10              |        |		ADDA.W	#0x10,A7
00020f62 4a 2e fb f5              |J.      |		TST.B	(A6-0x40b)
00020f66 66 36                    |f6      |		BNE	0x20f9e
00020f68 9e fc 00 38              |   8    |		SUBA.W	#0x38,A7
00020f6c 20 4f                    | O      |		MOVEA.L	A7,A0
00020f6e 43 fa f3 a0              |C       |		LEA.L	0x20310,A1
00020f72 72 36                    |r6      |		MOVEQ.L	#0x36,D1
00020f74 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020f76 51 c9 ff fc              |Q       |		DBF	D1,0x20f74
00020f7a 1f 3c 00 01              | <      |		MOVE.B	#0x01,-(A7)
00020f7e 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020f80 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
00020f84 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
00020f88 3f 3c 00 37              |?< 7    |		MOVE.W	#0x37,-(A7)
00020f8c 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00020f92 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020f94 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
00020f9a de fc 00 3e              |   >    |		ADDA.W	#0x3e,A7
00020f9e 7c 00                    ||       |		MOVEQ.L	#0x00,D6
00020fa0 7e 00                    |~       |		MOVEQ.L	#0x00,D7
00020fa2 53 80                    |S       |		SUBQ.L	#0x1,D0
00020fa4 b0 83                    |        |		CMP.L	D3,D0
00020fa6 63 02                    |c       |		BLS	0x20faa
00020fa8 4e 4f                    |NO      |		TRAP	#15
00020faa 34 80                    |4       |		MOVE.W	D0,(A2)
00020fac 4a 40                    |J@      |		TST.W	D0
00020fae 66 00 ff 04              |f       |		BNE	0x20eb4
00020fb2 33 c5 00 01 00 10        |3       |		MOVE.W	D5,0x10010
00020fb8 4e b9 00 01 03 90        |N       |		JSR	WriteFreeList(void)
00020fbe 4c df 0f ff              |L       |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D5+D6+D7+A0+A1+A2+A3
00020fc2 4e 5e                    |N^      |		UNLK	A6
00020fc4 4e 75                    |Nu      |		RTS
00020fc6 ; --------------------------------------------------------------------------------------
00020fc6 ; OMSI PASCAL Function
00020fc6 ; --------------------------------------------------------------------------------------
00020fc6					START:
00020fc6 4f fa 00 08              |O       |		LEA.L	MAIN,A7
00020fca 4e f9 00 01 02 80        |N       |		JMP	?start_program
00020fd0					MAIN:
00020fd0 45 f9 00 01 02 e4        |E       |		LEA.L	Long2String(a : Long) : String,A2
00020fd6 47 f9 00 02 64 c2        |G   d   |		LEA.L	0x264c2,A3
00020fdc 49 f9 00 02 64 c4        |I   d   |		LEA.L	0x264c4,A4
00020fe2 74 01                    |t       |		MOVEQ.L	#0x01,D2
00020fe4 76 1c                    |v       |		MOVEQ.L	#0x1c,D3
00020fe6 78 10                    |x       |		MOVEQ.L	#0x10,D4
00020fe8 7a 0c                    |z       |		MOVEQ.L	#0x0c,D5
00020fea 7c 24                    ||$      |		MOVEQ.L	#0x24,D6
00020fec 7e 12                    |~       |		MOVEQ.L	#0x12,D7
00020fee 41 f9 00 02 54 78        |A   Tx  |		LEA.L	0x25478,A0
00020ff4 2f 08                    |/       |		MOVE.L	A0,-(A7)
00020ff6 23 df 00 02 64 be        |#   d   |		MOVE.L	(A7)+,0x264be
00020ffc 41 f9 00 02 14 74        |A    t  |		LEA.L	0x21474,A0
00021002 2f 08                    |/       |		MOVE.L	A0,-(A7)
00021004 23 df 00 02 54 74        |#   Tt  |		MOVE.L	(A7)+,0x25474
0002100a 4e b9 00 01 03 98        |N       |		JSR	FSCALL_10398
00021010 4e ba f5 50              |N  P    |		JSR	0x20562
00021014 4e ba f5 ae              |N       |		JSR	0x205c4
00021018 48 53                    |HS      |		PEA.L	(A3)
0002101a 48 54                    |HT      |		PEA.L	(A4)
0002101c 48 79 00 02 64 c6        |Hy  d   |		PEA.L	0x264c6
00021022 4e ba f8 e2              |N       |		JSR	0x20906
00021026 de c5                    |        |		ADDA.W	D5,A7
00021028 48 79 00 02 64 cc        |Hy  d   |		PEA.L	0x264cc
0002102e 4e ba fa 48              |N  H    |		JSR	0x20a78
00021032 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00021034 4e b9 00 01 03 dc        |N       |		JSR	WriteConsoleCrLf(void)
0002103a 9e fc 00 18              |        |		SUBA.W	#0x18,A7
0002103e 20 4f                    | O      |		MOVEA.L	A7,A0
00021040 43 fa f3 26              |C  &    |		LEA.L	0x20368,A1
00021044 70 16                    |p       |		MOVEQ.L	#0x16,D0
00021046 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00021048 51 c8 ff fc              |Q       |		DBF	D0,0x21046
0002104c 59 4f                    |YO      |		SUBQ.L	#0x4,A7
0002104e 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
00021052 3f 02                    |?       |		MOVE.W	D2,-(A7)
00021054 3f 3c 00 17              |?<      |		MOVE.W	#0x17,-(A7)
00021058 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
0002105e 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00021060 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
00021066 de c3                    |        |		ADDA.W	D3,A7
00021068 70 01                    |p       |		MOVEQ.L	#0x01,D0
0002106a 23 c0 00 02 64 c8        |#   d   |		MOVE.L	D0,0x264c8
00021070 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00021072 2f 00                    |/       |		MOVE.L	D0,-(A7)
00021074 4e 92                    |N       |		JSR	(A2)
00021076 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00021078 48 78 00 05              |Hx      |		PEA.L	0x5
0002107c 4e b9 00 01 02 f4        |N       |		JSR	RightPad(a : String; b : Long) : String
00021082 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00021084 4e b9 00 01 03 d8        |N       |		JSR	WriteConsoleString(str : String)
0002108a 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002108c 52 80                    |R       |		ADDQ.L	#0x1,D0
0002108e b0 84                    |        |		CMP.L	D4,D0
00021090 6f d8                    |o       |		BLE	0x2106a
00021092 4e b9 00 01 03 dc        |N       |		JSR	WriteConsoleCrLf(void)
00021098 70 01                    |p       |		MOVEQ.L	#0x01,D0
0002109a 23 c0 00 02 64 c8        |#   d   |		MOVE.L	D0,0x264c8
000210a0 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000210a2 b0 84                    |        |		CMP.L	D4,D0
000210a4 63 02                    |c       |		BLS	0x210a8
000210a6 4e 4f                    |NO      |		TRAP	#15
000210a8 22 00                    |"       |		MOVE.L	D0,D1
000210aa e5 81                    |        |		ASL.L	#0x2,D1
000210ac 41 f9 00 02 14 6c        |A    l  |		LEA.L	0x2146c,A0
000210b2 41 f0 18 00              |A       |		LEA.L	(A0+D1.L),A0
000210b6 2f 28 50 0c              |/(P     |		MOVE.L	(A0+0x500c),-(A7)
000210ba 4e 92                    |N       |		JSR	(A2)
000210bc 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000210be 48 78 00 05              |Hx      |		PEA.L	0x5
000210c2 4e b9 00 01 02 f4        |N       |		JSR	RightPad(a : String; b : Long) : String
000210c8 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000210ca 4e b9 00 01 03 d8        |N       |		JSR	WriteConsoleString(str : String)
000210d0 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000210d2 52 80                    |R       |		ADDQ.L	#0x1,D0
000210d4 b0 84                    |        |		CMP.L	D4,D0
000210d6 6f c2                    |o       |		BLE	0x2109a
000210d8 4e b9 00 01 03 dc        |N       |		JSR	WriteConsoleCrLf(void)
000210de 9e c3                    |        |		SUBA.W	D3,A7
000210e0 20 4f                    | O      |		MOVEA.L	A7,A0
000210e2 43 fa f2 9c              |C       |		LEA.L	0x20380,A1
000210e6 70 1a                    |p       |		MOVEQ.L	#0x1a,D0
000210e8 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000210ea 51 c8 ff fc              |Q       |		DBF	D0,0x210e8
000210ee 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000210f0 2f 39 00 02 64 78        |/9  dx  |		MOVE.L	0x26478,-(A7)
000210f6 4e 92                    |N       |		JSR	(A2)
000210f8 48 6f 00 0c              |Ho      |		PEA.L	(A7+0xc)
000210fc 3f 02                    |?       |		MOVE.W	D2,-(A7)
000210fe 3f 3c 00 1b              |?<      |		MOVE.W	#0x1b,-(A7)
00021102 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00021108 50 4f                    |PO      |		ADDQ.L	#0x8,A7
0002110a 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
00021110 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00021112 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
00021118 de fc 00 20              |        |		ADDA.W	#0x20,A7
0002111c 41 fa f2 90              |A       |		LEA.L	0x203ae,A0
00021120 70 08                    |p       |		MOVEQ.L	#0x08,D0
00021122 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
00021124 51 c8 ff fc              |Q       |		DBF	D0,0x21122
00021128 9e c6                    |        |		SUBA.W	D6,A7
0002112a 20 4f                    | O      |		MOVEA.L	A7,A0
0002112c 43 fa f2 80              |C       |		LEA.L	0x203ae,A1
00021130 70 22                    |p"      |		MOVEQ.L	#0x22,D0
00021132 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00021134 51 c8 ff fc              |Q       |		DBF	D0,0x21132
00021138 51 4f                    |QO      |		SUBQ.L	#0x8,A7
0002113a 42 80                    |B       |		CLR.L	D0
0002113c 30 13                    |0       |		MOVE.W	(A3),D0
0002113e 2f 00                    |/       |		MOVE.L	D0,-(A7)
00021140 4e 92                    |N       |		JSR	(A2)
00021142 48 6f 00 30              |Ho 0    |		PEA.L	(A7+0x30)
00021146 3f 02                    |?       |		MOVE.W	D2,-(A7)
00021148 3f 07                    |?       |		MOVE.W	D7,-(A7)
0002114a 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00021150 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00021152 42 80                    |B       |		CLR.L	D0
00021154 30 14                    |0       |		MOVE.W	(A4),D0
00021156 2f 00                    |/       |		MOVE.L	D0,-(A7)
00021158 4e 92                    |N       |		JSR	(A2)
0002115a 48 6f 00 14              |Ho      |		PEA.L	(A7+0x14)
0002115e 3f 02                    |?       |		MOVE.W	D2,-(A7)
00021160 3f 3c 00 23              |?< #    |		MOVE.W	#0x23,-(A7)
00021164 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
0002116a 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002116c 42 80                    |B       |		CLR.L	D0
0002116e 30 39 00 02 64 c6        |09  d   |		MOVE.W	0x264c6,D0
00021174 2f 00                    |/       |		MOVE.L	D0,-(A7)
00021176 4e 92                    |N       |		JSR	(A2)
00021178 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002117a 4e b9 00 01 02 dc        |N       |		JSR	StringCat5(a, b, c, d, e : String) : String
00021180 de fc 00 14              |        |		ADDA.W	#0x14,A7
00021184 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
0002118a de fc 00 36              |   6    |		ADDA.W	#0x36,A7
0002118e 2e b9 00 02 64 cc        |.   d   |		MOVE.L	0x264cc,(A7)
00021194 4e ba fb b6              |N       |		JSR	0x20d4c
00021198 9e c3                    |        |		SUBA.W	D3,A7
0002119a 20 4f                    | O      |		MOVEA.L	A7,A0
0002119c 43 fa f1 aa              |C       |		LEA.L	0x20348,A1
000211a0 70 1e                    |p       |		MOVEQ.L	#0x1e,D0
000211a2 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000211a4 51 c8 ff fc              |Q       |		DBF	D0,0x211a2
000211a8 5d 4f                    |]O      |		SUBQ.L	#0x6,A7
000211aa 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
000211ae 3f 02                    |?       |		MOVE.W	D2,-(A7)
000211b0 3f 3c 00 1f              |?<      |		MOVE.W	#0x1f,-(A7)
000211b4 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
000211ba 5c 4f                    |\O      |		ADDQ.L	#0x6,A7
000211bc 42 17                    |B       |		CLR.B	(A7)
000211be 4e b9 00 01 03 f0        |N       |		JSR	AskOnConsoleYesNo(prompt : String; default : Bool) : Bool
000211c4 5c 4f                    |\O      |		ADDQ.L	#0x6,A7
000211c6 4a 1f                    |J       |		TST.B	(A7)+
000211c8 67 00 00 84              |g       |		BEQ	0x2124e
000211cc 48 53                    |HS      |		PEA.L	(A3)
000211ce 48 54                    |HT      |		PEA.L	(A4)
000211d0 48 79 00 02 64 c6        |Hy  d   |		PEA.L	0x264c6
000211d6 4e ba fc 9c              |N       |		JSR	0x20e74
000211da de c5                    |        |		ADDA.W	D5,A7
000211dc 41 fa f2 06              |A       |		LEA.L	0x203e4,A0
000211e0 70 08                    |p       |		MOVEQ.L	#0x08,D0
000211e2 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
000211e4 51 c8 ff fc              |Q       |		DBF	D0,0x211e2
000211e8 9e c6                    |        |		SUBA.W	D6,A7
000211ea 20 4f                    | O      |		MOVEA.L	A7,A0
000211ec 43 fa f1 f6              |C       |		LEA.L	0x203e4,A1
000211f0 70 22                    |p"      |		MOVEQ.L	#0x22,D0
000211f2 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000211f4 51 c8 ff fc              |Q       |		DBF	D0,0x211f2
000211f8 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000211fa 42 80                    |B       |		CLR.L	D0
000211fc 30 13                    |0       |		MOVE.W	(A3),D0
000211fe 2f 00                    |/       |		MOVE.L	D0,-(A7)
00021200 4e 92                    |N       |		JSR	(A2)
00021202 48 6f 00 30              |Ho 0    |		PEA.L	(A7+0x30)
00021206 3f 02                    |?       |		MOVE.W	D2,-(A7)
00021208 3f 07                    |?       |		MOVE.W	D7,-(A7)
0002120a 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00021210 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00021212 42 80                    |B       |		CLR.L	D0
00021214 30 14                    |0       |		MOVE.W	(A4),D0
00021216 2f 00                    |/       |		MOVE.L	D0,-(A7)
00021218 4e 92                    |N       |		JSR	(A2)
0002121a 48 6f 00 14              |Ho      |		PEA.L	(A7+0x14)
0002121e 3f 02                    |?       |		MOVE.W	D2,-(A7)
00021220 3f 3c 00 23              |?< #    |		MOVE.W	#0x23,-(A7)
00021224 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
0002122a 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002122c 42 80                    |B       |		CLR.L	D0
0002122e 30 39 00 02 64 c6        |09  d   |		MOVE.W	0x264c6,D0
00021234 2f 00                    |/       |		MOVE.L	D0,-(A7)
00021236 4e 92                    |N       |		JSR	(A2)
00021238 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002123a 4e b9 00 01 02 dc        |N       |		JSR	StringCat5(a, b, c, d, e : String) : String
00021240 de fc 00 14              |        |		ADDA.W	#0x14,A7
00021244 4e b9 00 01 03 e0        |N       |		JSR	WriteConsoleStringCrLf(str : String)
0002124a de fc 00 3a              |   :    |		ADDA.W	#0x3a,A7
0002124e de fc 00 1e              |        |		ADDA.W	#0x1e,A7
00021252 42 17                    |B       |		CLR.B	(A7)
00021254 48 78 00 01              |Hx      |		PEA.L	0x1
00021258 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
0002125e 5c 4f                    |\O      |		ADDQ.L	#0x6,A7
00021260 4e b9 00 01 02 84        |N       |		JSR	?exit
00021266 57 6f 72 64 73 20 65 72  |Words er|		.TXT	'Words error :_'
00021274 ; --------------------------------------------------------------------------------------
00021274 ; OMSI PASCAL Function
00021274 ;    <LVAR  0x008 1(r)>
00021274 ; --------------------------------------------------------------------------------------
00021274					PROG_FAIL:
00021274 4e 56 ff d2              |NV      |		LINK.W	A6,#0xffd2
00021278 bf d5                    |        |		CMPA.L	(A5),A7
0002127a 62 06                    |b       |		BHI	0x21282
0002127c 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
00021280 4e 76                    |Nv      |		TRAPV
00021282 de fc 00 2c              |   ,    |		ADDA.W	#0x2c,A7
00021286 48 e7 80 80              |H       |		MOVEM.L	A0+D0,-(A7)
0002128a 41 fa ff e8              |A       |		LEA.L	PROG_FAIL,A0
0002128e 70 06                    |p       |		MOVEQ.L	#0x06,D0
00021290 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
00021292 51 c8 ff fc              |Q       |		DBF	D0,0x21290
00021296 1f 3c 00 03              | <      |		MOVE.B	#0x03,-(A7)
0002129a 51 4f                    |QO      |		SUBQ.L	#0x8,A7
0002129c 48 6f 00 0a              |Ho      |		PEA.L	(A7+0xa)
000212a0 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
000212a4 3f 3c 00 0e              |?<      |		MOVE.W	#0xe,-(A7)
000212a8 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
000212ae 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000212b0 10 2e 00 08              | .      |		MOVE.B	(A6+0x8),D0
000212b4 48 80                    |H       |		EXTB.W	D0
000212b6 48 c0                    |H       |		EXTW.L	D0
000212b8 2f 00                    |/       |		MOVE.L	D0,-(A7)
000212ba 4e b9 00 01 02 e4        |N       |		JSR	Long2String(a : Long) : String
000212c0 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000212c2 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
000212c8 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000212ca 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
000212d0 de fc 00 14              |        |		ADDA.W	#0x14,A7
000212d4 4c df 01 01              |L       |		MOVEM.L	(A7)+,D0+A0
000212d8 4e 5e                    |N^      |		UNLK	A6
000212da 4e 75                    |Nu      |		RTS
000212dc 42 6f 61 72 64 20 20 20  |Board   |		.TXT	'Board      :_ '
000212ea 45 78 70 65 72 69 6d 65  |Experime|		.TXT	'Experiment :_ '
000212f8 53 74 61 74 75 73 20 20  |Status  |		.TXT	'Status     :_ '
00021306 45 78 70 65 72 69 6d 65  |Experime|		.TXT	'Experiment error :'
00021318 46 61 74 61 6c 20 65 78  |Fatal ex|		.TXT	'Fatal experiment error. '
00021330 ; --------------------------------------------------------------------------------------
00021330 ; OMSI PASCAL Function
00021330 ;    <LVAR  0x00e 1(r)>
00021330 ;    <LVAR  0x00a 4(r)>
00021330 ;    <LVAR  0x008 1(r)>
00021330 ; --------------------------------------------------------------------------------------
00021330					EXP_FAIL:
00021330 4e 56 ff 8c              |NV      |		LINK.W	A6,#0xff8c
00021334 bf d5                    |        |		CMPA.L	(A5),A7
00021336 62 06                    |b       |		BHI	0x2133e
00021338 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
0002133c 4e 76                    |Nv      |		TRAPV
0002133e de fc 00 74              |   t    |		ADDA.W	#0x74,A7
00021342 48 e7 fc f8              |H       |		MOVEM.L	A4+A3+A2+A1+A0+D5+D4+D3+D2+D1+D0,-(A7)
00021346 47 f9 00 01 02 c4        |G       |		LEA.L	StringLit(Src : Pointer; Offset: W; Len : W) : String,A3
0002134c 49 f9 00 01 03 e0        |I       |		LEA.L	WriteConsoleStringCrLf(str : String),A4
00021352 72 01                    |r       |		MOVEQ.L	#0x01,D1
00021354 74 0d                    |t       |		MOVEQ.L	#0x0d,D2
00021356 76 1e                    |v       |		MOVEQ.L	#0x1e,D3
00021358 78 12                    |x       |		MOVEQ.L	#0x12,D4
0002135a 7a 0e                    |z       |		MOVEQ.L	#0x0e,D5
0002135c 4e b9 00 01 03 dc        |N       |		JSR	WriteConsoleCrLf(void)
00021362 41 fa ff b4              |A       |		LEA.L	0x21318,A0
00021366 70 08                    |p       |		MOVEQ.L	#0x08,D0
00021368 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
0002136a 51 c8 ff fc              |Q       |		DBF	D0,0x21368
0002136e 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00021370 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
00021374 3f 01                    |?       |		MOVE.W	D1,-(A7)
00021376 3f 04                    |?       |		MOVE.W	D4,-(A7)
00021378 4e 93                    |N       |		JSR	(A3)
0002137a 50 4f                    |PO      |		ADDQ.L	#0x8,A7
0002137c 4e 94                    |N       |		JSR	(A4)
0002137e 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00021380 20 4f                    | O      |		MOVEA.L	A7,A0
00021382 43 fa ff 58              |C  X    |		LEA.L	0x212dc,A1
00021386 70 0c                    |p       |		MOVEQ.L	#0x0c,D0
00021388 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
0002138a 51 c8 ff fc              |Q       |		DBF	D0,0x21388
0002138e 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00021390 48 6f 00 08              |Ho      |		PEA.L	(A7+0x8)
00021394 3f 01                    |?       |		MOVE.W	D1,-(A7)
00021396 3f 02                    |?       |		MOVE.W	D2,-(A7)
00021398 4e 93                    |N       |		JSR	(A3)
0002139a 54 4f                    |TO      |		ADDQ.L	#0x2,A7
0002139c 1e ae 00 0e              |        |		MOVE.B	(A6+0xe),(A7)
000213a0 4e b9 00 01 04 9c        |N       |		JSR	BoardName(address : B) : String
000213a6 54 4f                    |TO      |		ADDQ.L	#0x2,A7
000213a8 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
000213ae 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000213b0 4e 94                    |N       |		JSR	(A4)
000213b2 de c4                    |        |		ADDA.W	D4,A7
000213b4 20 6e 00 0a              | n      |		MOVEA.L	(A6+0xa),A0
000213b8 b0 c1                    |        |		CMPA.W	D1,A0
000213ba 67 48                    |gH      |		BEQ	0x21404
000213bc 9e c5                    |        |		SUBA.W	D5,A7
000213be 22 4f                    |"O      |		MOVEA.L	A7,A1
000213c0 45 fa ff 28              |E  (    |		LEA.L	0x212ea,A2
000213c4 70 0c                    |p       |		MOVEQ.L	#0x0c,D0
000213c6 12 da                    |        |		MOVE.B	(A2)+,(A1)+
000213c8 51 c8 ff fc              |Q       |		DBF	D0,0x213c6
000213cc 9e c3                    |        |		SUBA.W	D3,A7
000213ce 22 4f                    |"O      |		MOVEA.L	A7,A1
000213d0 41 e8 00 fc              |A       |		LEA.L	(A0+0xfc),A0
000213d4 70 1d                    |p       |		MOVEQ.L	#0x1d,D0
000213d6 12 d8                    |        |		MOVE.B	(A0)+,(A1)+
000213d8 51 c8 ff fc              |Q       |		DBF	D0,0x213d6
000213dc 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000213de 48 6f 00 26              |Ho &    |		PEA.L	(A7+0x26)
000213e2 3f 01                    |?       |		MOVE.W	D1,-(A7)
000213e4 3f 02                    |?       |		MOVE.W	D2,-(A7)
000213e6 4e 93                    |N       |		JSR	(A3)
000213e8 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000213ea 48 6f 00 0c              |Ho      |		PEA.L	(A7+0xc)
000213ee 3f 01                    |?       |		MOVE.W	D1,-(A7)
000213f0 3f 03                    |?       |		MOVE.W	D3,-(A7)
000213f2 4e 93                    |N       |		JSR	(A3)
000213f4 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000213f6 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
000213fc 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000213fe 4e 94                    |N       |		JSR	(A4)
00021400 de fc 00 30              |   0    |		ADDA.W	#0x30,A7
00021404 9e c5                    |        |		SUBA.W	D5,A7
00021406 20 4f                    | O      |		MOVEA.L	A7,A0
00021408 43 fa fe ee              |C       |		LEA.L	0x212f8,A1
0002140c 70 0c                    |p       |		MOVEQ.L	#0x0c,D0
0002140e 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00021410 51 c8 ff fc              |Q       |		DBF	D0,0x2140e
00021414 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00021416 48 6f 00 08              |Ho      |		PEA.L	(A7+0x8)
0002141a 3f 01                    |?       |		MOVE.W	D1,-(A7)
0002141c 3f 02                    |?       |		MOVE.W	D2,-(A7)
0002141e 4e 93                    |N       |		JSR	(A3)
00021420 54 4f                    |TO      |		ADDQ.L	#0x2,A7
00021422 1e ae 00 08              |        |		MOVE.B	(A6+0x8),(A7)
00021426 4e b9 00 01 04 a2        |N       |		JSR	ExpStatus2Text(status.B, &String)
0002142c 54 4f                    |TO      |		ADDQ.L	#0x2,A7
0002142e 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
00021434 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00021436 4e 94                    |N       |		JSR	(A4)
00021438 5d 4f                    |]O      |		SUBQ.L	#0x6,A7
0002143a 20 4f                    | O      |		MOVEA.L	A7,A0
0002143c 43 fa fe da              |C       |		LEA.L	0x21318,A1
00021440 70 16                    |p       |		MOVEQ.L	#0x16,D0
00021442 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00021444 51 c8 ff fc              |Q       |		DBF	D0,0x21442
00021448 1f 3c 00 02              | <      |		MOVE.B	#0x02,-(A7)
0002144c 59 4f                    |YO      |		SUBQ.L	#0x4,A7
0002144e 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
00021452 3f 01                    |?       |		MOVE.W	D1,-(A7)
00021454 3f 3c 00 17              |?<      |		MOVE.W	#0x17,-(A7)
00021458 4e 93                    |N       |		JSR	(A3)
0002145a 50 4f                    |PO      |		ADDQ.L	#0x8,A7
0002145c 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
00021462 de c3                    |        |		ADDA.W	D3,A7
00021464 4c df 1f 3f              |L  ?    |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D5+A0+A1+A2+A3+A4
00021468 4e 5e                    |N^      |		UNLK	A6
0002146a 4e 75                    |Nu      |		RTS