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

⟦65ce8c14c⟧ M200

    Length: 2048 (0x800)
    Types: M200
    Notes: M200_PROGRAM
    Names: »P2USEQ.M200«

Derivation

└─⟦b4205821b⟧ Bits:30000743 8mm tape, Rational 1000, DFS, D_12_7_3 SEQ288
    └─ ⟦this⟧ »P2USEQ.M200« 
└─⟦b434774df⟧ Bits:30000528 8mm tape, Rational 1000, DFS, D_12_6_5
    └─ ⟦this⟧ »P2USEQ.M200« 
    └─ ⟦this⟧ »P2USEQ.M200« 
└─⟦bc1274df5⟧ Bits:30000750 8mm tape, Rational 1000, DFS backup from PAM's R1000
    └─ ⟦this⟧ »P2USEQ.M200« 

Disassembly

0x20164


@ 20164
EXP_FAIL
        <LVAR  0x00e 1(r)>
        <LVAR  0x00a 4(r)>
        <LVAR  0x008 1(r)>
    <POP 20164-202a0 Body>                                              
        <POP 20164-2017a Prologue>                           Σ0         ↓
        <POP 2017a-20190 RegCacheLoad>                       Σ0         ↓
        <POP 20190-201f0 Naked>                              Σ0         ↓ →0x20238
            <Call 0x20190 0x103dc>                                              {}
                WriteConsoleCrLf(void)
            <Blob 0x20196 [18] @>                            Δ-18               {[«18""»]}
            <POP 201a2-201a4 StackAdj>                       Δ-4                {[«18""»]|[-4-]}
            <Lit 0x201a4 18>                                                    {[«18""»]|[$$Experiment error :]}
            <Call 0x201b0 0x103e0>                                              {[«18""»]|[$$Experiment error :]}
                WriteConsoleStringCrLf(str : String)
            <POP 201b2-201b3 StackAdj>                       Δ+22       ↓       {}
            <Blob 0x201b3 [14] @>                            Δ-14               {[«14""»]}
            <POP 201c2-201c4 StackAdj>                       Δ-8                {[«14""»]|[-8-]}
            <Lit 0x201c4 13>                                                    {[«14""»]|[-4-]|[$$Board      :_]}
            <POP 201ce-201d0 StackAdj>                       Δ-6                {[«14""»]|[-4-]|[$$Board      :_]|[-6-]}
            <MI 201d0  MOVE.B  (A6+0xe),(A7)>                                   {[«14""»]|[-4-]|[$$Board      :_]|[-6-]}
            <Call 0x201d4 0x1049c>                                              {[«14""»]|[-4-]|[$$Board      :_]|[-6-]}
                BoardName(address : B) : String
            <POP 201da-201dc StackAdj>                       Δ+2                {[«14""»]|[-4-]|[$$Board      :_]|[-4-]}
            <Call 0x201dc 0x102d0>                                              {[«14""»]|[-4-]|[$$Board      :_]|[-4-]}
                StringCat2(a, b : String) : String
            <POP 201e2-201e4 StackAdj>                       Δ+8                {[«14""»]|[-4-]}
            <Call 0x201e4 0x103e0>                                              {[«14""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 201e6-201e8 StackAdj>                       Δ+18               {}
            <MI 201e8  MOVEA.L (A6+0xa),A0>                                     {}
            <MI 201ec  CMPA.W  #0x01,A0>                                        {}
            <MI 201ee  BEQ     0x20238>                                         {}
        <POP 201f0-20238 Naked>                              Σ0         ↓
            <Blob 0x201f0 [14] @>                            Δ-14               {[«14""»]}
            <Blob 0x20200 [30] (A0+0xfc)>                    Δ-30               {[«14""»]|[«30»]}
            <POP 20210-20212 StackAdj>                       Δ-8                {[«14""»]|[«30»]|[-8-]}
            <Lit 0x20212 13>                                                    {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]}
            <POP 2021c-2021e StackAdj>                       Δ-4                {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]|[-4-]}
            <Lit 0x2021e>                                                       {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]|[$$…]}
                <Pointer.sp 0x2021e 12>                      Δ-4        
                <Const 0x20222 0x1.2>                        Δ-2        
                <Const 0x20224 0x1e.2>                       Δ-2        
                <Call 0x20226 0x102c4>
                    StringLit(Src : Pointer; Offset: W; Len : W) : String
                <POP 20228-2022a StackAdj>                   Δ+8        
            <Call 0x2022a 0x102d0>                                              {[«14""»]|[«30»]|[-4-]|[$$Experiment :_]|[$$…]}
                StringCat2(a, b : String) : String
            <POP 20230-20232 StackAdj>                       Δ+8                {[«14""»]|[«30»]|[-4-]}
            <Call 0x20232 0x103e0>                                              {[«14""»]|[«30»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 20234-20238 StackAdj>                       Δ+48               {}
        <POP 20238-20298 Naked>                              Σ0         ↓ ←0x20190
            <Blob 0x20238 [14] @>                            Δ-14               {[«14""»]}
            <POP 20248-2024a StackAdj>                       Δ-8                {[«14""»]|[-8-]}
            <Lit 0x2024a 13>                                                    {[«14""»]|[-4-]|[$$Status     :_]}
            <POP 20254-20256 StackAdj>                       Δ-6                {[«14""»]|[-4-]|[$$Status     :_]|[-6-]}
            <MI 20256  MOVE.B  (A6+0x8),(A7)>                                   {[«14""»]|[-4-]|[$$Status     :_]|[-6-]}
            <Call 0x2025a 0x104a2>                                              {[«14""»]|[-4-]|[$$Status     :_]|[-6-]}
                ExpStatus2Text(status.B, &String)
            <POP 20260-20262 StackAdj>                       Δ+2                {[«14""»]|[-4-]|[$$Status     :_]|[-4-]}
            <Call 0x20262 0x102d0>                                              {[«14""»]|[-4-]|[$$Status     :_]|[-4-]}
                StringCat2(a, b : String) : String
            <POP 20268-2026a StackAdj>                       Δ+8                {[«14""»]|[-4-]}
            <Call 0x2026a 0x103e0>                                              {[«14""»]|[-4-]}
                WriteConsoleStringCrLf(str : String)
            <POP 2026c-2026d StackAdj>                       Δ+18       ↓       {}
            <Blob 0x2026d [24] @>                            Δ-24               {[«24""»]}
            <Const 0x2027c 0x2.2>                            Δ-2                {[«24""»]|[#2]}
            <POP 20280-20282 StackAdj>                       Δ-4                {[«24""»]|[#2]|[-4-]}
            <Lit 0x20282 23>                                                    {[«24""»]|[#2]|[$$Fatal experiment error.]}
            <Call 0x20290 0x103b8>                                              {[«24""»]|[#2]|[$$Fatal experiment error.]}
                PopProgram(status : Byte; msg : String)
            <POP 20296-20298 StackAdj>                       Δ+30               {}
        <POP 20298-202a0 Epilogue>                           Σ0         

0x202a0


@ 202a0
START
    <POP 202a0--0001 Body>                                   Δ+20       
        <POP 202a0-202aa Prologue>                           Σ0         
        <POP 202aa-202c2 RegCacheLoad>                       Σ0         ↓
        <POP 202c2-2032a Naked>                              Σ0         ↓
            <Call 0x202c2 0x10398>                                              {}
                FSCALL_10398
            <Const 0x202c8 0x2050b.4>                        Δ-4                {[##132363]}
            <Const 0x202ce 0x2050c.4>                        Δ-4                {[##132363]|[##132364]}
            <Call 0x202d4 0x10544>                                              {[##132363]|[##132364]}
                IPC_InitGetTwoBools(VAR a : Bool; VAR b : Bool)
            <POP 202da-202dc StackAdj>                       Δ+8                {}
            <Const 0x202dc 0x0.4>                            Δ-4                {[##0]}
            <Call 0x202e0 0x104d8>                                              {[##0]}
                ExpInit(a : Long)
            <POP 202e6-202e8 StackAdj>                       Δ+2                {[-2-]}
            <POP 202e8-202e9 StackAdj>                       Δ+2                {}
            <Blob 0x202e9 [2] 0x2050c>                       Δ-2                {[«2»]}
            <Call 0x202ee 0x104d2>                                              {[«2»]}
                SetExpInitDone(a : Byte)
            <POP 202f4-202f5 StackAdj>                       Δ+2                {}
            <Blob 0x202f5 [2] @>                             Δ-2                {[«2""»]}
            <Blob 0x202f8 [2] @>                             Δ-2                {[«2""»]|[«2""»]}
            <Blob 0x202fc [2] @>                             Δ-2                {[«2""»]|[«2""»]|[«2""»]}
            <POP 20300-20302 StackAdj>                       Δ-4                {[«2""»]|[«2""»]|[«2""»]|[-4-]}
            <Lit 0x20302 6>                                                     {[«2""»]|[«2""»]|[«2""»]|[$$P2USEQ]}
            <MI 20316  MOVE.L  (A7)+,0x204f8>                Δ+4                {[«2""»]|[«2""»]|[«2""»]}
            <POP 20318-2031a StackAdj>                       Δ+6                {}
            <Const 0x2031a 0x204fc.4>                        Δ-4                {[##132348]}
            <Call 0x2031c 0x102b8>                                              {[##132348]}
                NewString(VAR a : String)
            <POP 20322-20324 StackAdj>                       Δ+4                {}
            <MI 20324  MOVE.B  #0x05,0x20501>                                   {}
            <MI 20328  MOVEQ.L #0x01,D0>                                        {}
        <POP 2032a-20346 Naked>                              Σ0         ↓ →0x2032a ←0x2032a
            <MI 2032a  MOVE.L  D0,0x20516>                                      {}
            <POP 0x20330 LimitCheck 0x0 ≤ D0 ≤ 0x7>                             {}
            <MI 20336  LEA.L   0x204f0,A0>                                      {}
            <MI 2033c  CLR.B   (A0+D0.L+#0x11)>                                 {}
            <MI 20340  ADDQ.L  #0x1,D0>                                         {}
            <MI 20342  CMP.L   #0x07,D0>                                        {}
            <MI 20344  BLE     0x2032a>                                         {}
        <POP 20346-2038c Naked>                              Σ0 Δ-4     ↓ →0x203ea
            <Const 0x20346 0x20509.4>                        Δ-4                {[##132361]}
            <Call 0x2034c 0x2041e>                                              {[##132361]}
                exp_READ_CUR_UADR.SEQ(&Sr_2)
            <POP 20352-20354 StackAdj>                       Δ+2                {[-2-]}
            <POP 20354-20355 StackAdj>                       Δ+2                {}
            <Blob 0x20355 [2] 0x20509>                       Δ-2                {[«2»]}
            <MI 2035a  MOVE.B  0x2050a,(A7+0x1)>                                {[«2»]}
            <Const 0x20362 0x201.2>                          Δ-2                {[«2»]|[#513]}
            <POP 20366-20368 StackAdj>                       Δ-2                {[«2»]|[#513]|[-2-]}
            <Pointer.sp 0x20368 4>                           Δ-4                {[«2»]|[#513]|[-2-]|[^^4]}
            <Const 0x2036c 0x0.4>                            Δ-4                {[«2»]|[#513]|[-2-]|[^^4]|[##0]}
            <Const 0x20370 0x1.4>                            Δ-4                {[«2»]|[#513]|[-2-]|[^^4]|[##0]|[##1]}
            <Pointer.sp 0x20374 14>                          Δ-4                {[«2»]|[#513]|[-2-]|[^^4]|[##0]|[##1]|[^^14]}
            <Const 0x20378 0x0.4>                            Δ-4                {[«2»]|[#513]|[-2-]|[^^4]|[##0]|[##1]|[^^14]|[##0]}
            <Const 0x2037c 0x1.4>                            Δ-4                {[«2»]|[#513]|[-2-]|[^^4]|[##0]|[##1]|[^^14]|[##0]|[##1]}
            <Call 0x20380 0x104a8>                                              {[«2»]|[#513]|[-2-]|[^^4]|[##0]|[##1]|[^^14]|[##0]|[##1]}
                ?FS104a8(VAR : Pointer; b : L; c : L ; VAR : Pointer; e: L; f : L) : Bool
            <POP 20386-20388 StackAdj>                       Δ+24               {[«2»]|[#513]|[-2-]}
            <MI 20388  TST.B   (A7)+>                        Δ+2                {[«2»]|[#513]}
            <MI 2038a  BEQ     0x203ea>                                         {[«2»]|[#513]}
        <POP 2038c-203ba Naked>                              Σ-4        ↓ →0x203c4
            <Call 0x2038c 0x2045c>                                              {[-4-]}
                exp_PREP_READ_REG.VAL()
            <Const 0x20392 0x80.2>                           Δ-2                {[-4-]|[#128]}
            <MI 20396  CLR.B   -(A7)>                        Δ-2                {[-4-]|[#128]|[#0]}
            <Const 0x20398 0x2050d.4>                        Δ-4                {[-4-]|[#128]|[#0]|[##132365]}
            <Call 0x2039e 0x2043e>                                              {[-4-]|[#128]|[#0]|[##132365]}
                exp_READ_B_REG.VAL(Sw_2, Sw_1, &Sr_8)
            <POP 203a4-203a6 StackAdj>                       Δ+8                {[-4-]}
            <MI 203a6  TST.B   0x20514>                                         {[-4-]}
            <MI 203ac  CLR.L   D0>                                              {[-4-]}
            <MI 203ae  MOVE.B  0x20514,D0>                                      {[-4-]}
            <MI 203b4  CMPI.W  #0x0017,D0>                                      {[-4-]}
            <MI 203b8  BLS     0x203c4>                                         {[-4-]}
        <POP 203ba-203c4 Naked>                              Σ-4        →0x203ce
            <MI 203ba  MOVE.B  #0x27,0x20501>                                   {[-4-]}
            <MI 203bc  MOVE.B  #0x18,0x20500>                                   {[-4-]}
            <MI 203c2  BRA     0x203ce>                                         {[-4-]}
        <POP 203c4-203ce Naked>                              Σ-4        ↓ ←0x2038c
            <MI 203c4  MOVE.B  0x20514,0x20500>                                 {[-4-]}
        <POP 203ce-203ea Naked>                              Σ-4 Δ-20   →0x2040c ←0x203ba
            <MI 203ce  CLR.B   -(A7)>                        Δ-2                {[-4-]|[#0]}
            <Blob 0x203d0 [4] 0x204f8>                       Δ-4                {[-4-]|[#0]|[«4»]}
            <Blob 0x203d2 [4] 0x204fc>                       Δ-4                {[-4-]|[#0]|[«4»]|[«4»]}
            <Blob 0x203d4 [2] 0x20500>                       Δ-2                {[-4-]|[#0]|[«4»]|[«4»]|[«2»]}
            <Blob 0x203da [8] 0x20501>                       Δ-8                {[-4-]|[#0]|[«4»]|[«4»]|[«2»]|[«8»]}
            <MI 203e8  BRA     0x2040c>                                         {[-4-]|[#0]|[«4»]|[«4»]|[«2»]|[«8»]}
        <POP 203ea-2040c Naked>                              Σ-4 Δ-20   ↓ ←0x20346
            <MI 203ea  MOVE.B  #0x27,0x20501>                                   {[-4-]}
            <MI 203ec  MOVE.B  #0x18,0x20500>                                   {[-4-]}
            <MI 203f2  CLR.B   -(A7)>                        Δ-2                {[-4-]|[#0]}
            <Blob 0x203f4 [4] 0x204f8>                       Δ-4                {[-4-]|[#0]|[«4»]}
            <Blob 0x203f6 [4] 0x204fc>                       Δ-4                {[-4-]|[#0]|[«4»]|[«4»]}
            <Blob 0x203f8 [2] 0x20500>                       Δ-2                {[-4-]|[#0]|[«4»]|[«4»]|[«2»]}
            <Blob 0x203fe [8] 0x20501>                       Δ-8                {[-4-]|[#0]|[«4»]|[«4»]|[«2»]|[«8»]}
        <POP 2040c-20418 Naked>                              Σ-24 Δ+24  ↓ ←0x203ce
            <Call 0x2040c 0x1054a>                                              {[-24-]}
                ?IPC_Puts(a : Bool; b : String; c : String; d: Bool; e : Long; f : Long)
            <POP 20412-20416 StackAdj>                       Δ+20               {[-4-]}
            <POP 20416-20418 StackAdj>                       Δ+4                {}
        <POP 20418-2041e Naked>                              Σ0         
            <Call 0x20418 0x10284>                                              {}
                ?exit

0x20488


@ 20488
PROG_FAIL
        <LVAR  0x008 1(r)>
    <POP 20488-204f0 Body>                                              
        <POP 20488-2049e Prologue>                           Σ0         ↓
        <POP 2049e-204e8 Naked>                              Σ0         ↓
            <Blob 0x2049e [14] @>                            Δ-14               {[«14""»]}
            <Const 0x204aa 0x3.2>                            Δ-2                {[«14""»]|[#3]}
            <POP 204ae-204b0 StackAdj>                       Δ-8                {[«14""»]|[#3]|[-8-]}
            <Lit 0x204b0 14>                                                    {[«14""»]|[#3]|[-4-]|[$$Words error :_]}
            <POP 204c2-204c4 StackAdj>                       Δ-4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 204c4  MOVE.B  (A6+0x8),D0>                                     {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 204c8  EXTB.W  D0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 204ca  EXTW.L  D0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 204cc  MOVE.L  D0,-(A7)>                     Δ-4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]|[4, 'D0']}
            <Call 0x204ce 0x102e4>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]|[4, 'D0']}
                Long2String(a : Long) : String
            <POP 204d4-204d6 StackAdj>                       Δ+4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <Call 0x204d6 0x102d0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
                StringCat2(a, b : String) : String
            <POP 204dc-204de StackAdj>                       Δ+8                {[«14""»]|[#3]|[-4-]}
            <Call 0x204de 0x103b8>                                              {[«14""»]|[#3]|[-4-]}
                PopProgram(status : Byte; msg : String)
            <POP 204e4-204e8 StackAdj>                       Δ+20               {}
        <POP 204e8-204f0 Epilogue>                           Σ0         

Raw from R1000.Disassembly/DFS

00020000 ; --------------------------------------------------------------------------------------
00020000 ; R1000.Disassembly modules:
00020000 ;   import all
00020000 ;   import kind.program
00020000 ;   no ident.febe6207757fffd9
00020000 ; --------------------------------------------------------------------------------------
00020000					stack.top:
00020000 00 04 00 00              |        |		.CODE	0x40000			; STACK.END
00020004 00 02 02 a0              |        |		.CODE	START
00020008 00 01 02 88              |        |		.CODE	FSCALL_10288
0002000c					heap.top:
0002000c 00 02 05 24              |   $    |		.PTR	0x20524
00020010					code.end:
00020010 00 02 04 f0              |        |		.PTR	0x204f0
00020014 00 00 00 00              |        |		.CONST	0x00000000
00020018					programfailurehandler:
00020018 00 02 04 88              |        |		.CODE	PROG_FAIL
0002001c					experimentfailurehandler:
0002001c 00 02 01 64              |   d    |		.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 42 6f 61 72 64 20 20 20  |Board   |		.TXT	'Board      :_ '
00020118 45 78 70 65 72 69 6d 65  |Experime|		.TXT	'Experiment :_ '
00020126 53 74 61 74 75 73 20 20  |Status  |		.TXT	'Status     :_ '
00020134 45 78 70 65 72 69 6d 65  |Experime|		.TXT	'Experiment error :'
00020146 46 61 74 61 6c 20 65 78  |Fatal ex|		.TXT	'Fatal experiment error. '
0002015e 50 32                    |P2      |		.TXT	'P2'
00020160 55 53                    |US      |		.TXT	'US'
00020162 45 51                    |EQ      |		.TXT	'EQ'
00020164 ; --------------------------------------------------------------------------------------
00020164 ; OMSI PASCAL Function
00020164 ;    <LVAR  0x00e 1(r)>
00020164 ;    <LVAR  0x00a 4(r)>
00020164 ;    <LVAR  0x008 1(r)>
00020164 ; --------------------------------------------------------------------------------------
00020164					EXP_FAIL:
00020164 4e 56 ff 8c              |NV      |		LINK.W	A6,#0xff8c
00020168 bf d5                    |        |		CMPA.L	(A5),A7
0002016a 62 06                    |b       |		BHI	0x20172
0002016c 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
00020170 4e 76                    |Nv      |		TRAPV
00020172 de fc 00 74              |   t    |		ADDA.W	#0x74,A7
00020176 48 e7 fc f8              |H       |		MOVEM.L	A4+A3+A2+A1+A0+D5+D4+D3+D2+D1+D0,-(A7)
0002017a 47 f9 00 01 02 c4        |G       |		LEA.L	StringLit(Src : Pointer; Offset: W; Len : W) : String,A3
00020180 49 f9 00 01 03 e0        |I       |		LEA.L	WriteConsoleStringCrLf(str : String),A4
00020186 72 01                    |r       |		MOVEQ.L	#0x01,D1
00020188 74 0d                    |t       |		MOVEQ.L	#0x0d,D2
0002018a 76 1e                    |v       |		MOVEQ.L	#0x1e,D3
0002018c 78 12                    |x       |		MOVEQ.L	#0x12,D4
0002018e 7a 0e                    |z       |		MOVEQ.L	#0x0e,D5
00020190 4e b9 00 01 03 dc        |N       |		JSR	WriteConsoleCrLf(void)
00020196 41 fa ff ae              |A       |		LEA.L	0x20146,A0
0002019a 70 08                    |p       |		MOVEQ.L	#0x08,D0
0002019c 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
0002019e 51 c8 ff fc              |Q       |		DBF	D0,0x2019c
000201a2 59 4f                    |YO      |		SUBQ.L	#0x4,A7
000201a4 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
000201a8 3f 01                    |?       |		MOVE.W	D1,-(A7)
000201aa 3f 04                    |?       |		MOVE.W	D4,-(A7)
000201ac 4e 93                    |N       |		JSR	(A3)
000201ae 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000201b0 4e 94                    |N       |		JSR	(A4)
000201b2 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000201b4 20 4f                    | O      |		MOVEA.L	A7,A0
000201b6 43 fa ff 52              |C  R    |		LEA.L	0x2010a,A1
000201ba 70 0c                    |p       |		MOVEQ.L	#0x0c,D0
000201bc 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000201be 51 c8 ff fc              |Q       |		DBF	D0,0x201bc
000201c2 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000201c4 48 6f 00 08              |Ho      |		PEA.L	(A7+0x8)
000201c8 3f 01                    |?       |		MOVE.W	D1,-(A7)
000201ca 3f 02                    |?       |		MOVE.W	D2,-(A7)
000201cc 4e 93                    |N       |		JSR	(A3)
000201ce 54 4f                    |TO      |		ADDQ.L	#0x2,A7
000201d0 1e ae 00 0e              |        |		MOVE.B	(A6+0xe),(A7)
000201d4 4e b9 00 01 04 9c        |N       |		JSR	BoardName(address : B) : String
000201da 54 4f                    |TO      |		ADDQ.L	#0x2,A7
000201dc 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
000201e2 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000201e4 4e 94                    |N       |		JSR	(A4)
000201e6 de c4                    |        |		ADDA.W	D4,A7
000201e8 20 6e 00 0a              | n      |		MOVEA.L	(A6+0xa),A0
000201ec b0 c1                    |        |		CMPA.W	D1,A0
000201ee 67 48                    |gH      |		BEQ	0x20238
000201f0 9e c5                    |        |		SUBA.W	D5,A7
000201f2 22 4f                    |"O      |		MOVEA.L	A7,A1
000201f4 45 fa ff 22              |E  "    |		LEA.L	0x20118,A2
000201f8 70 0c                    |p       |		MOVEQ.L	#0x0c,D0
000201fa 12 da                    |        |		MOVE.B	(A2)+,(A1)+
000201fc 51 c8 ff fc              |Q       |		DBF	D0,0x201fa
00020200 9e c3                    |        |		SUBA.W	D3,A7
00020202 22 4f                    |"O      |		MOVEA.L	A7,A1
00020204 41 e8 00 fc              |A       |		LEA.L	(A0+0xfc),A0
00020208 70 1d                    |p       |		MOVEQ.L	#0x1d,D0
0002020a 12 d8                    |        |		MOVE.B	(A0)+,(A1)+
0002020c 51 c8 ff fc              |Q       |		DBF	D0,0x2020a
00020210 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00020212 48 6f 00 26              |Ho &    |		PEA.L	(A7+0x26)
00020216 3f 01                    |?       |		MOVE.W	D1,-(A7)
00020218 3f 02                    |?       |		MOVE.W	D2,-(A7)
0002021a 4e 93                    |N       |		JSR	(A3)
0002021c 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002021e 48 6f 00 0c              |Ho      |		PEA.L	(A7+0xc)
00020222 3f 01                    |?       |		MOVE.W	D1,-(A7)
00020224 3f 03                    |?       |		MOVE.W	D3,-(A7)
00020226 4e 93                    |N       |		JSR	(A3)
00020228 50 4f                    |PO      |		ADDQ.L	#0x8,A7
0002022a 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
00020230 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020232 4e 94                    |N       |		JSR	(A4)
00020234 de fc 00 30              |   0    |		ADDA.W	#0x30,A7
00020238 9e c5                    |        |		SUBA.W	D5,A7
0002023a 20 4f                    | O      |		MOVEA.L	A7,A0
0002023c 43 fa fe e8              |C       |		LEA.L	0x20126,A1
00020240 70 0c                    |p       |		MOVEQ.L	#0x0c,D0
00020242 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020244 51 c8 ff fc              |Q       |		DBF	D0,0x20242
00020248 51 4f                    |QO      |		SUBQ.L	#0x8,A7
0002024a 48 6f 00 08              |Ho      |		PEA.L	(A7+0x8)
0002024e 3f 01                    |?       |		MOVE.W	D1,-(A7)
00020250 3f 02                    |?       |		MOVE.W	D2,-(A7)
00020252 4e 93                    |N       |		JSR	(A3)
00020254 54 4f                    |TO      |		ADDQ.L	#0x2,A7
00020256 1e ae 00 08              |        |		MOVE.B	(A6+0x8),(A7)
0002025a 4e b9 00 01 04 a2        |N       |		JSR	ExpStatus2Text(status.B, &String)
00020260 54 4f                    |TO      |		ADDQ.L	#0x2,A7
00020262 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
00020268 50 4f                    |PO      |		ADDQ.L	#0x8,A7
0002026a 4e 94                    |N       |		JSR	(A4)
0002026c 5d 4f                    |]O      |		SUBQ.L	#0x6,A7
0002026e 20 4f                    | O      |		MOVEA.L	A7,A0
00020270 43 fa fe d4              |C       |		LEA.L	0x20146,A1
00020274 70 16                    |p       |		MOVEQ.L	#0x16,D0
00020276 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020278 51 c8 ff fc              |Q       |		DBF	D0,0x20276
0002027c 1f 3c 00 02              | <      |		MOVE.B	#0x02,-(A7)
00020280 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020282 48 6f 00 06              |Ho      |		PEA.L	(A7+0x6)
00020286 3f 01                    |?       |		MOVE.W	D1,-(A7)
00020288 3f 3c 00 17              |?<      |		MOVE.W	#0x17,-(A7)
0002028c 4e 93                    |N       |		JSR	(A3)
0002028e 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020290 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
00020296 de c3                    |        |		ADDA.W	D3,A7
00020298 4c df 1f 3f              |L  ?    |		MOVEM.L	(A7)+,D0+D1+D2+D3+D4+D5+A0+A1+A2+A3+A4
0002029c 4e 5e                    |N^      |		UNLK	A6
0002029e 4e 75                    |Nu      |		RTS
000202a0 ; --------------------------------------------------------------------------------------
000202a0 ; OMSI PASCAL Function
000202a0 ; --------------------------------------------------------------------------------------
000202a0					START:
000202a0 4f fa 00 08              |O       |		LEA.L	MAIN,A7
000202a4 4e f9 00 01 02 80        |N       |		JMP	?start_program
000202aa					MAIN:
000202aa 45 f9 00 02 05 01        |E       |		LEA.L	0x20501,A2
000202b0 47 f9 00 02 04 f8        |G       |		LEA.L	0x204f8,A3
000202b6 49 f9 00 02 04 fc        |I       |		LEA.L	0x204fc,A4
000202bc 72 18                    |r       |		MOVEQ.L	#0x18,D1
000202be 74 07                    |t       |		MOVEQ.L	#0x07,D2
000202c0 76 27                    |v'      |		MOVEQ.L	#0x27,D3
000202c2 4e b9 00 01 03 98        |N       |		JSR	FSCALL_10398
000202c8 48 79 00 02 05 0b        |Hy      |		PEA.L	0x2050b
000202ce 48 79 00 02 05 0c        |Hy      |		PEA.L	0x2050c
000202d4 4e b9 00 01 05 44        |N    D  |		JSR	IPC_InitGetTwoBools(VAR a : Bool; VAR b : Bool)
000202da 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000202dc 48 78 00 00              |Hx      |		PEA.L	0x0
000202e0 4e b9 00 01 04 d8        |N       |		JSR	ExpInit(a : Long)
000202e6 54 4f                    |TO      |		ADDQ.L	#0x2,A7
000202e8 1e b9 00 02 05 0c        |        |		MOVE.B	0x2050c,(A7)
000202ee 4e b9 00 01 04 d2        |N       |		JSR	SetExpInitDone(a : Byte)
000202f4 3e ba fe 6c              |>  l    |		MOVE.W	0x20162,(A7)
000202f8 3f 3a fe 66              |?: f    |		MOVE.W	0x20160,-(A7)
000202fc 3f 3a fe 60              |?: `    |		MOVE.W	0x2015e,-(A7)
00020300 59 4f                    |YO      |		SUBQ.L	#0x4,A7
00020302 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
00020306 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
0002030a 3f 3c 00 06              |?<      |		MOVE.W	#0x6,-(A7)
0002030e 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00020314 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020316 26 9f                    |&       |		MOVE.L	(A7)+,(A3)
00020318 5c 4f                    |\O      |		ADDQ.L	#0x6,A7
0002031a 48 54                    |HT      |		PEA.L	(A4)
0002031c 4e b9 00 01 02 b8        |N       |		JSR	NewString(VAR a : String)
00020322 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020324 14 bc 00 05              |        |		MOVE.B	#0x05,(A2)
00020328 70 01                    |p       |		MOVEQ.L	#0x01,D0
0002032a 23 c0 00 02 05 16        |#       |		MOVE.L	D0,0x20516
00020330 b0 82                    |        |		CMP.L	D2,D0
00020332 63 02                    |c       |		BLS	0x20336
00020334 4e 4f                    |NO      |		TRAP	#15
00020336 41 f9 00 02 04 f0        |A       |		LEA.L	0x204f0,A0
0002033c 42 30 08 11              |B0      |		CLR.B	(A0+D0.L+#0x11)
00020340 52 80                    |R       |		ADDQ.L	#0x1,D0
00020342 b0 82                    |        |		CMP.L	D2,D0
00020344 6f e4                    |o       |		BLE	0x2032a
00020346 48 79 00 02 05 09        |Hy      |		PEA.L	0x20509
0002034c 4e b9 00 02 04 1e        |N       |		JSR	exp_READ_CUR_UADR.SEQ(&Sr_2)
00020352 54 4f                    |TO      |		ADDQ.L	#0x2,A7
00020354 1e b9 00 02 05 09        |        |		MOVE.B	0x20509,(A7)
0002035a 1f 79 00 02 05 0a 00 01  | y      |		MOVE.B	0x2050a,(A7+0x1)
00020362 3f 3c 02 01              |?<      |		MOVE.W	#0x201,-(A7)
00020366 55 4f                    |UO      |		SUBQ.L	#0x2,A7
00020368 48 6f 00 04              |Ho      |		PEA.L	(A7+0x4)
0002036c 48 78 00 00              |Hx      |		PEA.L	0x0
00020370 48 78 00 01              |Hx      |		PEA.L	0x1
00020374 48 6f 00 0e              |Ho      |		PEA.L	(A7+0xe)
00020378 48 78 00 00              |Hx      |		PEA.L	0x0
0002037c 48 78 00 01              |Hx      |		PEA.L	0x1
00020380 4e b9 00 01 04 a8        |N       |		JSR	?FS104a8(VAR : Pointer; b : L; c : L ; VAR : Pointer; e: L; f : L) : Bool
00020386 de c1                    |        |		ADDA.W	D1,A7
00020388 4a 1f                    |J       |		TST.B	(A7)+
0002038a 67 5e                    |g^      |		BEQ	0x203ea
0002038c 4e b9 00 02 04 5c        |N    \  |		JSR	exp_PREP_READ_REG.VAL()
00020392 3f 3c 00 80              |?<      |		MOVE.W	#0x80,-(A7)
00020396 42 27                    |B'      |		CLR.B	-(A7)
00020398 48 79 00 02 05 0d        |Hy      |		PEA.L	0x2050d
0002039e 4e b9 00 02 04 3e        |N    >  |		JSR	exp_READ_B_REG.VAL(Sw_2, Sw_1, &Sr_8)
000203a4 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000203a6 4a 39 00 02 05 14        |J9      |		TST.B	0x20514
000203ac 42 80                    |B       |		CLR.L	D0
000203ae 10 39 00 02 05 14        | 9      |		MOVE.B	0x20514,D0
000203b4 0c 40 00 17              | @      |		CMPI.W	#0x0017,D0
000203b8 63 0a                    |c       |		BLS	0x203c4
000203ba 14 83                    |        |		MOVE.B	D3,(A2)
000203bc 13 c1 00 02 05 00        |        |		MOVE.B	D1,0x20500
000203c2 60 0a                    |`       |		BRA	0x203ce
000203c4 13 f9 00 02 05 14 00 02  |        |		MOVE.B	0x20514,0x20500
000203cc 05 00                    |        |
000203ce 42 27                    |B'      |		CLR.B	-(A7)
000203d0 2f 13                    |/       |		MOVE.L	(A3),-(A7)
000203d2 2f 14                    |/       |		MOVE.L	(A4),-(A7)
000203d4 1f 39 00 02 05 00        | 9      |		MOVE.B	0x20500,-(A7)
000203da 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000203dc 20 4f                    | O      |		MOVEA.L	A7,A0
000203de 22 4a                    |"J      |		MOVEA.L	A2,A1
000203e0 70 07                    |p       |		MOVEQ.L	#0x07,D0
000203e2 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000203e4 51 c8 ff fc              |Q       |		DBF	D0,0x203e2
000203e8 60 22                    |`"      |		BRA	0x2040c
000203ea 14 83                    |        |		MOVE.B	D3,(A2)
000203ec 13 c1 00 02 05 00        |        |		MOVE.B	D1,0x20500
000203f2 42 27                    |B'      |		CLR.B	-(A7)
000203f4 2f 13                    |/       |		MOVE.L	(A3),-(A7)
000203f6 2f 14                    |/       |		MOVE.L	(A4),-(A7)
000203f8 1f 39 00 02 05 00        | 9      |		MOVE.B	0x20500,-(A7)
000203fe 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00020400 20 4f                    | O      |		MOVEA.L	A7,A0
00020402 22 4a                    |"J      |		MOVEA.L	A2,A1
00020404 70 07                    |p       |		MOVEQ.L	#0x07,D0
00020406 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
00020408 51 c8 ff fc              |Q       |		DBF	D0,0x20406
0002040c 4e b9 00 01 05 4a        |N    J  |		JSR	?IPC_Puts(a : Bool; b : String; c : String; d: Bool; e : Long; f : Long)
00020412 de fc 00 14              |        |		ADDA.W	#0x14,A7
00020416 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020418 4e b9 00 01 02 84        |N       |		JSR	?exit
0002041e					exp_READ_CUR_UADR.SEQ(&Sr_2):
0002041e 4e b9 00 01 05 68        |N    h  |		JSR	Run_Experiment()
00020424 00 0c                    |        |		.CONST	0x000c			; Stack-delta
00020426 11 52 45 41 44 5f 43 55  | READ_CU|		.TXT	17,'READ_CUR_UADR.SEQ'
00020438 00                       |        |		.CONST	0x0
00020439 02                       |        |		.CONST	0x2			; DIPROC address
0002043a 01                       |        |		.CONST	0x1			; Output Parameters
0002043b 00                       |        |		.CONST	0x0			; Input Parameters
0002043c 01                       |        |		.CONST	0x1			; Out arg [2]
0002043d 00                       |        |		.PAD	0x0
0002043e					exp_READ_B_REG.VAL(Sw_2, Sw_1, &Sr_8):
0002043e 4e b9 00 01 05 68        |N    h  |		JSR	Run_Experiment()
00020444 00 10                    |        |		.CONST	0x0010			; Stack-delta
00020446 0e 52 45 41 44 5f 42 5f  | READ_B_|		.TXT	14,'READ_B_REG.VAL'
00020455 00                       |        |		.CONST	0x0
00020456 07                       |        |		.CONST	0x7			; DIPROC address
00020457 01                       |        |		.CONST	0x1			; Output Parameters
00020458 02                       |        |		.CONST	0x2			; Input Parameters
00020459 01                       |        |		.CONST	0x1			; In arg [2]
0002045a 00                       |        |		.CONST	0x0			; In arg [1]
0002045b 07                       |        |		.CONST	0x7			; Out arg [8]
0002045c					exp_PREP_READ_REG.VAL():
0002045c 4e b9 00 01 05 68        |N    h  |		JSR	Run_Experiment()
00020462 00 08                    |        |		.CONST	0x0008			; Stack-delta
00020464 11 50 52 45 50 5f 52 45  | PREP_RE|		.TXT	17,'PREP_READ_REG.VAL'
00020476 00                       |        |		.CONST	0x0
00020477 07                       |        |		.CONST	0x7			; DIPROC address
00020478 00                       |        |		.CONST	0x0			; Output Parameters
00020479 00                       |        |		.CONST	0x0			; Input Parameters
0002047a 57 6f 72 64 73 20 65 72  |Words er|		.TXT	'Words error :_'
00020488 ; --------------------------------------------------------------------------------------
00020488 ; OMSI PASCAL Function
00020488 ;    <LVAR  0x008 1(r)>
00020488 ; --------------------------------------------------------------------------------------
00020488					PROG_FAIL:
00020488 4e 56 ff d2              |NV      |		LINK.W	A6,#0xffd2
0002048c bf d5                    |        |		CMPA.L	(A5),A7
0002048e 62 06                    |b       |		BHI	0x20496
00020490 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
00020494 4e 76                    |Nv      |		TRAPV
00020496 de fc 00 2c              |   ,    |		ADDA.W	#0x2c,A7
0002049a 48 e7 80 80              |H       |		MOVEM.L	A0+D0,-(A7)
0002049e 41 fa ff e8              |A       |		LEA.L	PROG_FAIL,A0
000204a2 70 06                    |p       |		MOVEQ.L	#0x06,D0
000204a4 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
000204a6 51 c8 ff fc              |Q       |		DBF	D0,0x204a4
000204aa 1f 3c 00 03              | <      |		MOVE.B	#0x03,-(A7)
000204ae 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000204b0 48 6f 00 0a              |Ho      |		PEA.L	(A7+0xa)
000204b4 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
000204b8 3f 3c 00 0e              |?<      |		MOVE.W	#0xe,-(A7)
000204bc 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
000204c2 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000204c4 10 2e 00 08              | .      |		MOVE.B	(A6+0x8),D0
000204c8 48 80                    |H       |		EXTB.W	D0
000204ca 48 c0                    |H       |		EXTW.L	D0
000204cc 2f 00                    |/       |		MOVE.L	D0,-(A7)
000204ce 4e b9 00 01 02 e4        |N       |		JSR	Long2String(a : Long) : String
000204d4 58 4f                    |XO      |		ADDQ.L	#0x4,A7
000204d6 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
000204dc 50 4f                    |PO      |		ADDQ.L	#0x8,A7
000204de 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
000204e4 de fc 00 14              |        |		ADDA.W	#0x14,A7
000204e8 4c df 01 01              |L       |		MOVEM.L	(A7)+,D0+A0
000204ec 4e 5e                    |N^      |		UNLK	A6
000204ee 4e 75                    |Nu      |		RTS