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

⟦2a8fdebb0⟧ M200

    Length: 1536 (0x600)
    Types: M200
    Notes: M200_PROGRAM
    Names: »P2UFIU.M200«

Derivation

└─⟦24d56d853⟧ Bits:30000744 8mm tape, Rational 1000, DFS, D_12_6_5 SEQ293
    └─ ⟦this⟧ »P2UFIU.M200« 
└─⟦9031b0687⟧ Bits:30000407 8mm tape, Rational 1000, DFS, D_12_7_3
    └─ ⟦this⟧ »P2UFIU.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>                                              
        <POP 202a0-202aa Prologue>                           Σ0         
        <POP 202aa-202c2 RegCacheLoad>                       Σ0         ↓
        <POP 202c2-2036a Naked>                              Σ0         ↓ →0x20374
            <Call 0x202c2 0x10398>                                              {}
                FSCALL_10398
            <Const 0x202c8 0x204af.4>                        Δ-4                {[##132271]}
            <Const 0x202ce 0x204b0.4>                        Δ-4                {[##132271]|[##132272]}
            <Call 0x202d4 0x10544>                                              {[##132271]|[##132272]}
                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] 0x204b0>                       Δ-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""»]|[$$P2UFIU]}
            <MI 20312  MOVE.L  (A7)+,0x2049e>                Δ+4                {[«2""»]|[«2""»]|[«2""»]}
            <POP 20318-2031a StackAdj>                       Δ+6                {}
            <Const 0x2031a 0x204a2.4>                        Δ-4                {[##132258]}
            <Call 0x20320 0x102b8>                                              {[##132258]}
                NewString(VAR a : String)
            <POP 20326-20328 StackAdj>                       Δ+4                {}
            <Call 0x20328 0x20402>                                              {}
                exp_PREP_READ_REG.VAL()
            <Const 0x2032e 0x1.2>                            Δ-2                {[#1]}
            <MI 20330  CLR.B   -(A7)>                        Δ-2                {[#1]|[#0]}
            <Const 0x20332 0x204b1.4>                        Δ-4                {[#1]|[#0]|[##132273]}
            <Call 0x20338 0x203c4>                                              {[#1]|[#0]|[##132273]}
                exp_REG_TO_LOOP.VAL(Sw_1, Sw_1, &Sr_2)
            <POP 2033e-20340 StackAdj>                       Δ+6                {[#1]}
            <POP 20340-20341 StackAdj>                       Δ+2                {}
            <Blob 0x20341 [2] 0x204b1>                       Δ-2                {[«2»]}
            <MI 20346  MOVE.B  0x204b2,(A7+0x1)>                                {[«2»]}
            <MI 2034e  CLR.B   -(A7)>                        Δ-2                {[«2»]|[#0]}
            <Const 0x20350 0x204b8.4>                        Δ-4                {[«2»]|[#0]|[##132280]}
            <Call 0x20356 0x203e4>                                              {[«2»]|[#0]|[##132280]}
                exp_READ_B_REG.VAL(Sw_2, Sw_1, &Sr_8)
            <POP 2035c-2035e StackAdj>                       Δ+8                {}
            <MI 2035e  TST.B   0x204bf>                                         {}
            <MI 20360  CLR.L   D0>                                              {}
            <MI 20362  MOVE.B  0x204bf,D0>                                      {}
            <MI 20364  CMPI.W  #0x000d,D0>                                      {}
            <MI 20368  BLS     0x20374>                                         {}
        <POP 2036a-20374 Naked>                              Σ0         →0x20378
            <MI 2036a  MOVE.B  #0x27,0x204a7>                                   {}
            <MI 2036e  MOVE.B  #0x0e,0x204a6>                                   {}
            <MI 20372  BRA     0x20378>                                         {}
        <POP 20374-20378 Naked>                              Σ0         ↓ ←0x202c2
            <MI 20374  MOVE.B  #0x06,0x204a7>                                   {}
            <MI 20376  MOVE.B  0x204bf,0x204a6>                                 {}
        <POP 20378-2037a Naked>                              Σ0         ↓ ←0x2036a
            <MI 20378  MOVEQ.L #0x01,D0>                                        {}
        <POP 2037a-20396 Naked>                              Σ0         ↓ →0x2037a ←0x2037a
            <MI 2037a  MOVE.L  D0,0x204b4>                                      {}
            <POP 0x20380 LimitCheck 0x0 ≤ D0 ≤ 0x7>                             {}
            <MI 20386  LEA.L   0x20496,A0>                                      {}
            <MI 2038c  CLR.B   (A0+D0.L+#0x11)>                                 {}
            <MI 20390  ADDQ.L  #0x1,D0>                                         {}
            <MI 20392  CMP.L   #0x07,D0>                                        {}
            <MI 20394  BLE     0x2037a>                                         {}
        <POP 20396-203be Naked>                              Σ0         ↓
            <MI 20396  CLR.B   -(A7)>                        Δ-2                {[#0]}
            <Blob 0x20398 [4] 0x2049e>                       Δ-4                {[#0]|[«4»]}
            <Blob 0x2039e [4] 0x204a2>                       Δ-4                {[#0]|[«4»]|[«4»]}
            <Blob 0x203a4 [2] 0x204a6>                       Δ-2                {[#0]|[«4»]|[«4»]|[«2»]}
            <Blob 0x203a6 [8] 0x204a7>                       Δ-8                {[#0]|[«4»]|[«4»]|[«2»]|[«8»]}
            <Call 0x203b4 0x1054a>                                              {[#0]|[«4»]|[«4»]|[«2»]|[«8»]}
                ?IPC_Puts(a : Bool; b : String; c : String; d: Bool; e : Long; f : Long)
            <POP 203ba-203be StackAdj>                       Δ+20               {}
        <POP 203be-203c4 Naked>                              Σ0         
            <Call 0x203be 0x10284>                                              {}
                ?exit

0x2042e


@ 2042e
PROG_FAIL
        <LVAR  0x008 1(r)>
    <POP 2042e-20496 Body>                                              
        <POP 2042e-20444 Prologue>                           Σ0         ↓
        <POP 20444-2048e Naked>                              Σ0         ↓
            <Blob 0x20444 [14] @>                            Δ-14               {[«14""»]}
            <Const 0x20450 0x3.2>                            Δ-2                {[«14""»]|[#3]}
            <POP 20454-20456 StackAdj>                       Δ-8                {[«14""»]|[#3]|[-8-]}
            <Lit 0x20456 14>                                                    {[«14""»]|[#3]|[-4-]|[$$Words error :_]}
            <POP 20468-2046a StackAdj>                       Δ-4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 2046a  MOVE.B  (A6+0x8),D0>                                     {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 2046e  EXTB.W  D0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 20470  EXTW.L  D0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <MI 20472  MOVE.L  D0,-(A7)>                     Δ-4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]|[4, 'D0']}
            <Call 0x20474 0x102e4>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]|[4, 'D0']}
                Long2String(a : Long) : String
            <POP 2047a-2047c StackAdj>                       Δ+4                {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
            <Call 0x2047c 0x102d0>                                              {[«14""»]|[#3]|[-4-]|[$$Words error :_]|[-4-]}
                StringCat2(a, b : String) : String
            <POP 20482-20484 StackAdj>                       Δ+8                {[«14""»]|[#3]|[-4-]}
            <Call 0x20484 0x103b8>                                              {[«14""»]|[#3]|[-4-]}
                PopProgram(status : Byte; msg : String)
            <POP 2048a-2048e StackAdj>                       Δ+20               {}
        <POP 2048e-20496 Epilogue>                           Σ0         

Raw from R1000.Disassembly/DFS

00020000 ; --------------------------------------------------------------------------------------
00020000 ; R1000.Disassembly modules:
00020000 ;   import all
00020000 ;   import kind.program
00020000 ;   no ident.dd4f59218bc4a164
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 04 ca              |        |		.PTR	0x204ca
00020010					code.end:
00020010 00 02 04 96              |        |		.PTR	0x20496
00020014 00 00 00 00              |        |		.CONST	0x00000000
00020018					programfailurehandler:
00020018 00 02 04 2e              |   .    |		.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 46                    |UF      |		.TXT	'UF'
00020162 49 55                    |IU      |		.TXT	'IU'
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 04 bf        |E       |		LEA.L	0x204bf,A2
000202b0 47 f9 00 02 04 a7        |G       |		LEA.L	0x204a7,A3
000202b6 49 f9 00 02 04 a6        |I       |		LEA.L	0x204a6,A4
000202bc 72 01                    |r       |		MOVEQ.L	#0x01,D1
000202be 74 06                    |t       |		MOVEQ.L	#0x06,D2
000202c0 76 07                    |v       |		MOVEQ.L	#0x07,D3
000202c2 4e b9 00 01 03 98        |N       |		JSR	FSCALL_10398
000202c8 48 79 00 02 04 af        |Hy      |		PEA.L	0x204af
000202ce 48 79 00 02 04 b0        |Hy      |		PEA.L	0x204b0
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 04 b0        |        |		MOVE.B	0x204b0,(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 01                    |?       |		MOVE.W	D1,-(A7)
00020308 3f 02                    |?       |		MOVE.W	D2,-(A7)
0002030a 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00020310 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020312 23 df 00 02 04 9e        |#       |		MOVE.L	(A7)+,0x2049e
00020318 5c 4f                    |\O      |		ADDQ.L	#0x6,A7
0002031a 48 79 00 02 04 a2        |Hy      |		PEA.L	0x204a2
00020320 4e b9 00 01 02 b8        |N       |		JSR	NewString(VAR a : String)
00020326 58 4f                    |XO      |		ADDQ.L	#0x4,A7
00020328 4e b9 00 02 04 02        |N       |		JSR	exp_PREP_READ_REG.VAL()
0002032e 1f 01                    |        |		MOVE.B	D1,-(A7)
00020330 42 27                    |B'      |		CLR.B	-(A7)
00020332 48 79 00 02 04 b1        |Hy      |		PEA.L	0x204b1
00020338 4e b9 00 02 03 c4        |N       |		JSR	exp_REG_TO_LOOP.VAL(Sw_1, Sw_1, &Sr_2)
0002033e 5c 4f                    |\O      |		ADDQ.L	#0x6,A7
00020340 1e b9 00 02 04 b1        |        |		MOVE.B	0x204b1,(A7)
00020346 1f 79 00 02 04 b2 00 01  | y      |		MOVE.B	0x204b2,(A7+0x1)
0002034e 42 27                    |B'      |		CLR.B	-(A7)
00020350 48 79 00 02 04 b8        |Hy      |		PEA.L	0x204b8
00020356 4e b9 00 02 03 e4        |N       |		JSR	exp_READ_B_REG.VAL(Sw_2, Sw_1, &Sr_8)
0002035c 50 4f                    |PO      |		ADDQ.L	#0x8,A7
0002035e 4a 12                    |J       |		TST.B	(A2)
00020360 42 80                    |B       |		CLR.L	D0
00020362 10 12                    |        |		MOVE.B	(A2),D0
00020364 0c 40 00 0d              | @      |		CMPI.W	#0x000d,D0
00020368 63 0a                    |c       |		BLS	0x20374
0002036a 16 bc 00 27              |   '    |		MOVE.B	#0x27,(A3)
0002036e 18 bc 00 0e              |        |		MOVE.B	#0x0e,(A4)
00020372 60 04                    |`       |		BRA	0x20378
00020374 16 82                    |        |		MOVE.B	D2,(A3)
00020376 18 92                    |        |		MOVE.B	(A2),(A4)
00020378 70 01                    |p       |		MOVEQ.L	#0x01,D0
0002037a 23 c0 00 02 04 b4        |#       |		MOVE.L	D0,0x204b4
00020380 b0 83                    |        |		CMP.L	D3,D0
00020382 63 02                    |c       |		BLS	0x20386
00020384 4e 4f                    |NO      |		TRAP	#15
00020386 41 f9 00 02 04 96        |A       |		LEA.L	0x20496,A0
0002038c 42 30 08 11              |B0      |		CLR.B	(A0+D0.L+#0x11)
00020390 52 80                    |R       |		ADDQ.L	#0x1,D0
00020392 b0 83                    |        |		CMP.L	D3,D0
00020394 6f e4                    |o       |		BLE	0x2037a
00020396 42 27                    |B'      |		CLR.B	-(A7)
00020398 2f 39 00 02 04 9e        |/9      |		MOVE.L	0x2049e,-(A7)
0002039e 2f 39 00 02 04 a2        |/9      |		MOVE.L	0x204a2,-(A7)
000203a4 1f 14                    |        |		MOVE.B	(A4),-(A7)
000203a6 51 4f                    |QO      |		SUBQ.L	#0x8,A7
000203a8 20 4f                    | O      |		MOVEA.L	A7,A0
000203aa 22 4b                    |"K      |		MOVEA.L	A3,A1
000203ac 70 07                    |p       |		MOVEQ.L	#0x07,D0
000203ae 10 d9                    |        |		MOVE.B	(A1)+,(A0)+
000203b0 51 c8 ff fc              |Q       |		DBF	D0,0x203ae
000203b4 4e b9 00 01 05 4a        |N    J  |		JSR	?IPC_Puts(a : Bool; b : String; c : String; d: Bool; e : Long; f : Long)
000203ba de fc 00 14              |        |		ADDA.W	#0x14,A7
000203be 4e b9 00 01 02 84        |N       |		JSR	?exit
000203c4					exp_REG_TO_LOOP.VAL(Sw_1, Sw_1, &Sr_2):
000203c4 4e b9 00 01 05 68        |N    h  |		JSR	Run_Experiment()
000203ca 00 10                    |        |		.CONST	0x0010			; Stack-delta
000203cc 0f 52 45 47 5f 54 4f 5f  | REG_TO_|		.TXT	15,'REG_TO_LOOP.VAL'
000203dc 00                       |        |		.CONST	0x0
000203dd 07                       |        |		.CONST	0x7			; DIPROC address
000203de 01                       |        |		.CONST	0x1			; Output Parameters
000203df 02                       |        |		.CONST	0x2			; Input Parameters
000203e0 00                       |        |		.CONST	0x0			; In arg [1]
000203e1 00                       |        |		.CONST	0x0			; In arg [1]
000203e2 01                       |        |		.CONST	0x1			; Out arg [2]
000203e3 00                       |        |		.PAD	0x0
000203e4					exp_READ_B_REG.VAL(Sw_2, Sw_1, &Sr_8):
000203e4 4e b9 00 01 05 68        |N    h  |		JSR	Run_Experiment()
000203ea 00 10                    |        |		.CONST	0x0010			; Stack-delta
000203ec 0e 52 45 41 44 5f 42 5f  | READ_B_|		.TXT	14,'READ_B_REG.VAL'
000203fb 00                       |        |		.CONST	0x0
000203fc 07                       |        |		.CONST	0x7			; DIPROC address
000203fd 01                       |        |		.CONST	0x1			; Output Parameters
000203fe 02                       |        |		.CONST	0x2			; Input Parameters
000203ff 01                       |        |		.CONST	0x1			; In arg [2]
00020400 00                       |        |		.CONST	0x0			; In arg [1]
00020401 07                       |        |		.CONST	0x7			; Out arg [8]
00020402					exp_PREP_READ_REG.VAL():
00020402 4e b9 00 01 05 68        |N    h  |		JSR	Run_Experiment()
00020408 00 08                    |        |		.CONST	0x0008			; Stack-delta
0002040a 11 50 52 45 50 5f 52 45  | PREP_RE|		.TXT	17,'PREP_READ_REG.VAL'
0002041c 00                       |        |		.CONST	0x0
0002041d 07                       |        |		.CONST	0x7			; DIPROC address
0002041e 00                       |        |		.CONST	0x0			; Output Parameters
0002041f 00                       |        |		.CONST	0x0			; Input Parameters
00020420 57 6f 72 64 73 20 65 72  |Words er|		.TXT	'Words error :_'
0002042e ; --------------------------------------------------------------------------------------
0002042e ; OMSI PASCAL Function
0002042e ;    <LVAR  0x008 1(r)>
0002042e ; --------------------------------------------------------------------------------------
0002042e					PROG_FAIL:
0002042e 4e 56 ff d2              |NV      |		LINK.W	A6,#0xffd2
00020432 bf d5                    |        |		CMPA.L	(A5),A7
00020434 62 06                    |b       |		BHI	0x2043c
00020436 44 fc 00 02              |D       |		MOVE.W	#0x2,CCR
0002043a 4e 76                    |Nv      |		TRAPV
0002043c de fc 00 2c              |   ,    |		ADDA.W	#0x2c,A7
00020440 48 e7 80 80              |H       |		MOVEM.L	A0+D0,-(A7)
00020444 41 fa ff e8              |A       |		LEA.L	PROG_FAIL,A0
00020448 70 06                    |p       |		MOVEQ.L	#0x06,D0
0002044a 3f 20                    |?       |		MOVE.W	-(A0),-(A7)
0002044c 51 c8 ff fc              |Q       |		DBF	D0,0x2044a
00020450 1f 3c 00 03              | <      |		MOVE.B	#0x03,-(A7)
00020454 51 4f                    |QO      |		SUBQ.L	#0x8,A7
00020456 48 6f 00 0a              |Ho      |		PEA.L	(A7+0xa)
0002045a 3f 3c 00 01              |?<      |		MOVE.W	#0x1,-(A7)
0002045e 3f 3c 00 0e              |?<      |		MOVE.W	#0xe,-(A7)
00020462 4e b9 00 01 02 c4        |N       |		JSR	StringLit(Src : Pointer; Offset: W; Len : W) : String
00020468 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002046a 10 2e 00 08              | .      |		MOVE.B	(A6+0x8),D0
0002046e 48 80                    |H       |		EXTB.W	D0
00020470 48 c0                    |H       |		EXTW.L	D0
00020472 2f 00                    |/       |		MOVE.L	D0,-(A7)
00020474 4e b9 00 01 02 e4        |N       |		JSR	Long2String(a : Long) : String
0002047a 58 4f                    |XO      |		ADDQ.L	#0x4,A7
0002047c 4e b9 00 01 02 d0        |N       |		JSR	StringCat2(a, b : String) : String
00020482 50 4f                    |PO      |		ADDQ.L	#0x8,A7
00020484 4e b9 00 01 03 b8        |N       |		JSR	PopProgram(status : Byte; msg : String)
0002048a de fc 00 14              |        |		ADDA.W	#0x14,A7
0002048e 4c df 01 01              |L       |		MOVEM.L	(A7)+,D0+A0
00020492 4e 5e                    |N^      |		UNLK	A6
00020494 4e 75                    |Nu      |		RTS