forked from kjseefried/Mil-std-1750A-Emulator
-
Notifications
You must be signed in to change notification settings - Fork 0
/
MetOp.c
1469 lines (1459 loc) · 113 KB
/
MetOp.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
00000000 : 7070005E : JC : GR( 7), RX( 0), DATA( 5E) ! Jump On Condition
*/
main();
void subroutine_0002()
{
/*
00000002 : 9F00 : PSHM : GR1(00), GR2(00) ! Push Multiple Registers On Stack
00000003 : 8500FF80 : LIM : GR( 0), RX( 0), DATA(FF80) ! Single Precision Integer Load
00000005 : 90002160 : ST : GR(00), RX(00), ADDR(2160) ! Single Precision Integer Store
00000007 : 91002161 : STC : GR(00), RX(00), ADDR(2161) ! Store a non negative constant
00000009 : 91002162 : STC : GR(00), RX(00), ADDR(2162) ! Store a non negative constant
0000000B : 91002163 : STC : GR(00), RX(00), ADDR(2163) ! Store a non negative constant
0000000D : 91002164 : STC : GR(00), RX(00), ADDR(2164) ! Store a non negative constant
0000000F : 91002165 : STC : GR(00), RX(00), ADDR(2165) ! Store a non negative constant
00000011 : 91002166 : STC : GR(00), RX(00), ADDR(2166) ! Store a non negative constant
00000013 : 8500C000 : LIM : GR( 0), RX( 0), DATA(C000) ! Single Precision Integer Load
00000015 : 48002000 : XIO : GR( 0), RX( 0), DATA(2000) ! Execute Input/Output
00000017 : 8F00 : POPM : GR1(00), GR2(00) ! Pop Multiple Registers Off the Stack
00000018 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void main()
{
/*
0000005E : 48002008 : XIO : GR( 0), RX( 0), DATA(2008) ! Execute Input/Output
00000060 : 48002003 : XIO : GR( 0), RX( 0), DATA(2003) ! Execute Input/Output
00000062 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000064 : 48002000 : XIO : GR( 0), RX( 0), DATA(2000) ! Execute Input/Output
00000066 : 48002001 : XIO : GR( 0), RX( 0), DATA(2001) ! Execute Input/Output
00000068 : 90007FA0 : ST : GR(00), RX(00), ADDR(7FA0) ! Single Precision Integer Store
0000006A : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
0000006C : 4800200E : XIO : GR( 0), RX( 0), DATA(200E) ! Execute Input/Output
0000006E : 85F02160 : LIM : GR( F), RX( 0), DATA(2160) ! Single Precision Integer Load
*/
/*
00000070 : 7EF0121E : SJS : GR( F), RX( 0), DATA(121E) ! Stack IC And Jump To Subroutine
*/
subroutine_121E();
/*
00000072 : 7EF0143D : SJS : GR( F), RX( 0), DATA(143D) ! Stack IC And Jump To Subroutine
*/
subroutine_143D();
/*
00000074 : 7EF00002 : SJS : GR( F), RX( 0), DATA( 2) ! Stack IC And Jump To Subroutine
*/
subroutine_0002();
/*
00000076 : 7EF012C0 : SJS : GR( F), RX( 0), DATA(12C0) ! Stack IC And Jump To Subroutine
*/
subroutine_12C0();
/*
00000078 : 7EF013EF : SJS : GR( F), RX( 0), DATA(13EF) ! Stack IC And Jump To Subroutine
*/
subroutine_13EF();
/*
0000007A : 7EF002C9 : SJS : GR( F), RX( 0), DATA( 2C9) ! Stack IC And Jump To Subroutine
*/
subroutine_02C9();
/*
0000007C : 7EF0082F : SJS : GR( F), RX( 0), DATA( 82F) ! Stack IC And Jump To Subroutine
*/
subroutine_082F();
/*
0000007E : 7EF0086A : SJS : GR( F), RX( 0), DATA( 86A) ! Stack IC And Jump To Subroutine
*/
subroutine_086A();
/*
00000080 : 7EF007B2 : SJS : GR( F), RX( 0), DATA( 7B2) ! Stack IC And Jump To Subroutine
*/
subroutine_07B2();
/*
00000082 : 7EF00910 : SJS : GR( F), RX( 0), DATA( 910) ! Stack IC And Jump To Subroutine
*/
subroutine_0B84();
/*
00000084 : 7EF00B84 : SJS : GR( F), RX( 0), DATA( B84) ! Stack IC And Jump To Subroutine
*/
subroutine_0B84();
/*
00000086 : 7EF00C94 : SJS : GR( F), RX( 0), DATA( C94) ! Stack IC And Jump To Subroutine
*/
subroutine_0C94();
/*
00000088 : 7EF00E29 : SJS : GR( F), RX( 0), DATA( E29) ! Stack IC And Jump To Subroutine
*/
subroutine_0E29();
/*
0000008A : 7EF008D5 : SJS : GR( F), RX( 0), DATA( 8D5) ! Stack IC And Jump To Subroutine
*/
subroutine_08D5();
/*
0000008C : 7EF00091 : SJS : GR( F), RX( 0), DATA( 91) ! Stack IC And Jump To Subroutine
*/
subroutine_0091();
/*
0000008E : 7EF01451 : SJS : GR( F), RX( 0), DATA(1451) ! Stack IC And Jump To Subroutine
*/
subroutine_1451();
}
void subroutine_0091()
{
/*
00000091 : 9F0E : PSHM : GR1(00), GR2(0E) ! Push Multiple Registers On Stack
00000092 : 4800A00F : XIO : GR( 0), RX( 0), DATA(A00F) ! Execute Input/Output
00000094 : 57D0 : TBR : GR1(0D), GR2(00) ! Test Bit
00000095 : 7505 : BEZ : DISPL(05) ! Branch if equal to zero
0000009A : E500 : XORR : GR1(00), GR2(00) ! Exclusive Logical OR
0000009B : 85100000 : LIM : GR( 1), RX( 0), DATA( 0) ! Single Precision Integer Load
0000009D : 4A1A1FFF : CIM : GR(01), DATA(1FFF) ! Single Precision Compare
0000009F : 7905 : BGT : DISPL(05) ! Branch if greater than zero
000000A0 : A0010000 : A : GR(00), RX(01), ADDR(0000) ! Single Precision Integer Add
000000A2 : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
000000A3 : 74FA : BR : DISPL(FA) ! Branch Unconditionally
000000A4 : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
000000A6 : 7505 : BEZ : DISPL(05) ! Branch if equal to zero
000000AB : 85102000 : LIM : GR( 1), RX( 0), DATA(2000) ! Single Precision Integer Load
000000AD : 85400000 : LIM : GR( 4), RX( 0), DATA( 0) ! Single Precision Integer Load
000000AF : 4A1A7BFF : CIM : GR(01), DATA(7BFF) ! Single Precision Compare
000000B1 : 7919 : BGT : DISPL(19) ! Branch if greater than zero
000000B2 : 80210000 : L : GR(02), RX(01), ADDR(0000) ! Single Precision Integer Load
000000B4 : 90110000 : ST : GR(01), RX(01), ADDR(0000) ! Single Precision Integer Store
000000B6 : F0110000 : C : GR(01), RX(01), ADDR(0000) ! Single Precision Compare
000000B8 : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
000000BB : 8530FFFF : LIM : GR( 3), RX( 0), DATA(FFFF) ! Single Precision Integer Load
000000BD : B0310000 : S : GR(03), RX(01), ADDR(0000) ! Single Precision Integer subtract
000000BF : 90310000 : ST : GR(03), RX(01), ADDR(0000) ! Single Precision Integer Store
000000C1 : F0310000 : C : GR(03), RX(01), ADDR(0000) ! Single Precision Compare
000000C3 : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
000000C6 : 90210000 : ST : GR(02), RX(01), ADDR(0000) ! Single Precision Integer Store
000000C8 : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
000000C9 : 74E6 : BR : DISPL(E6) ! Branch Unconditionally
000000CA : 4A4A0001 : CIM : GR(04), DATA(0001) ! Single Precision Compare
000000CC : 7A05 : BNZ : DISPL(05) ! Branch if not equal to zero
000000D1 : 8F0E : POPM : GR1(00), GR2(0E) ! Pop Multiple Registers Off the Stack
000000D2 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_00D3()
{
/*
000000D3 : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
000000D4 : 8110 : LR : GR1(01), GR2(00) ! Single Precision Integer Load
000000D5 : 71711513 : JCI : GR(07), RX(01), ADDR(1513) ! Jump On Condition
000000EF : 53402160 : RB : GR(04), RX(00), ADDR(2160) ! Reset Bit
000000F1 : 70700191 : JC : GR( 7), RX( 0), DATA( 191) ! Jump On Condition
0000018D : 53902160 : RB : GR(09), RX(00), ADDR(2160) ! Reset Bit
0000018F : 70700191 : JC : GR( 7), RX( 0), DATA( 191) ! Jump On Condition
00000191 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
00000192 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
/*
*
*/
void subroutine_0193()
{
/*
00000193 : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
00000194 : 7EF0136C : SJS : GR( F), RX( 0), DATA(136C) ! Stack IC And Jump To Subroutine
00000196 : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
00000198 : 7A18 : BNZ : DISPL(18) ! Branch if not equal to zero
00000199 : 7EF01374 : SJS : GR( F), RX( 0), DATA(1374) ! Stack IC And Jump To Subroutine
0000019B : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
0000019D : 7A13 : BNZ : DISPL(13) ! Branch if not equal to zero
0000019E : 8500009A : LIM : GR( 0), RX( 0), DATA( 9A) ! Single Precision Integer Load
000001A0 : 80102160 : L : GR(01), RX(00), ADDR(2160) ! Single Precision Integer Load
000001A2 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
*/
subroutine_1393();
/*
000001A4 : 8500009C : LIM : GR( 0), RX( 0), DATA( 9C) ! Single Precision Integer Load
000001A6 : 80102161 : L : GR(01), RX(00), ADDR(2161) ! Single Precision Integer Load
000001A8 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
*/
subroutine_1393();
/*
000001AA : 8500009E : LIM : GR( 0), RX( 0), DATA( 9E) ! Single Precision Integer Load
000001AC : 80102162 : L : GR(01), RX(00), ADDR(2162) ! Single Precision Integer Load
000001AE : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
*/
subroutine_1393();
/*
000001B0 : 8500001A : LIM : GR( 0), RX( 0), DATA( 1A) ! Single Precision Integer Load
000001B2 : 80102164 : L : GR(01), RX(00), ADDR(2164) ! Single Precision Integer Load
000001B4 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
*/
subroutine_1393();
/*
000001B6 : 85000018 : LIM : GR( 0), RX( 0), DATA( 18) ! Single Precision Integer Load
000001B8 : 80102163 : L : GR(01), RX(00), ADDR(2163) ! Single Precision Integer Load
000001BA : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
*/
subroutine_1393();
/*
000001BC : 8500001C : LIM : GR( 0), RX( 0), DATA( 1C) ! Single Precision Integer Load
000001BE : 80102165 : L : GR(01), RX(00), ADDR(2165) ! Single Precision Integer Load
000001C0 : 7EF01386 : SJS : GR( F), RX( 0), DATA(1386) ! Stack IC And Jump To Subroutine
*/
subroutine_1386();
/*
000001C2 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
000001C3 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_01C4()
{
/*
000001C4 : 9F12 : PSHM : GR1(01), GR2(02) ! Push Multiple Registers On Stack
000001C5 : 8120 : LR : GR1(02), GR2(00) ! Single Precision Integer Load
000001C6 : 7EF014FC : SJS : GR( F), RX( 0), DATA(14FC) ! Stack IC And Jump To Subroutine
000001C8 : 91002166 : STC : GR(00), RX(00), ADDR(2166) ! Store a non negative constant
000001CA : 80020000 : L : GR(00), RX(02), ADDR(0000) ! Single Precision Integer Load
000001CC : FF00 : NOP : GR1(00), GR2(00) ! No Operation
000001CD : 80202166 : L : GR(02), RX(00), ADDR(2166) ! Single Precision Integer Load
000001CF : 4A2A0001 : CIM : GR(02), DATA(0001) ! Single Precision Compare
000001D1 : 7A02 : BNZ : DISPL(02) ! Branch if not equal to zero
000001D3 : 7EF01505 : SJS : GR( F), RX( 0), DATA(1505) ! Stack IC And Jump To Subroutine
000001D5 : 8F12 : POPM : GR1(01), GR2(02) ! Pop Multiple Registers Off the Stack
000001D6 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_02C9()
{
/*
000002C9 : 9F00 : PSHM : GR1(00), GR2(00) ! Push Multiple Registers On Stack
000002CA : 85002167 : LIM : GR( 0), RX( 0), DATA(2167) ! Single Precision Integer Load
000002CC : 90002969 : ST : GR(00), RX(00), ADDR(2969) ! Single Precision Integer Store
000002CE : 85002568 : LIM : GR( 0), RX( 0), DATA(2568) ! Single Precision Integer Load
000002D0 : 9000296A : ST : GR(00), RX(00), ADDR(296A) ! Single Precision Integer Store
000002D2 : 91002A63 : STC : GR(00), RX(00), ADDR(2A63) ! Store a non negative constant
000002D4 : 91002A64 : STC : GR(00), RX(00), ADDR(2A64) ! Store a non negative constant
000002D6 : 91002A66 : STC : GR(00), RX(00), ADDR(2A66) ! Store a non negative constant
000002D8 : 91002A6A : STC : GR(00), RX(00), ADDR(2A6A) ! Store a non negative constant
000002DA : 91002A62 : STC : GR(00), RX(00), ADDR(2A62) ! Store a non negative constant
000002DC : 91002A69 : STC : GR(00), RX(00), ADDR(2A69) ! Store a non negative constant
000002DE : 91002A67 : STC : GR(00), RX(00), ADDR(2A67) ! Store a non negative constant
000002E0 : 91002A65 : STC : GR(00), RX(00), ADDR(2A65) ! Store a non negative constant
000002E2 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
000002E4 : 7EF01056 : SJS : GR( F), RX( 0), DATA(1056) ! Stack IC And Jump To Subroutine
000002E6 : 8F00 : POPM : GR1(00), GR2(00) ! Pop Multiple Registers Off the Stack
000002E7 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_033A()
{
/*
0000033A : 9F0E : PSHM : GR1(00), GR2(0E) ! Push Multiple Registers On Stack
0000033B : 80002A64 : L : GR(00), RX(00), ADDR(2A64) ! Single Precision Integer Load
0000033D : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
0000033F : 7A13 : BNZ : DISPL(13) ! Branch if not equal to zero
00000340 : 7EF0101C : SJS : GR( F), RX( 0), DATA(101C) ! Stack IC And Jump To Subroutine
00000342 : 91102A64 : STC : GR(01), RX(00), ADDR(2A64) ! Store a non negative constant
00000344 : 80002A69 : L : GR(00), RX(00), ADDR(2A69) ! Single Precision Integer Load
00000346 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00000348 : 7A06 : BNZ : DISPL(06) ! Branch if not equal to zero
0000034E : 8500001F : LIM : GR( 0), RX( 0), DATA( 1F) ! Single Precision Integer Load
00000350 : 7EF000D3 : SJS : GR( F), RX( 0), DATA( D3) ! Stack IC And Jump To Subroutine
00000352 : 7EF014FC : SJS : GR( F), RX( 0), DATA(14FC) ! Stack IC And Jump To Subroutine
00000354 : 80002A63 : L : GR(00), RX(00), ADDR(2A63) ! Single Precision Integer Load
00000356 : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
00000358 : 7A1D : BNZ : DISPL(1D) ! Branch if not equal to zero
00000359 : 80002A66 : L : GR(00), RX(00), ADDR(2A66) ! Single Precision Integer Load
0000035B : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
0000035D : 7510 : BEZ : DISPL(10) ! Branch if equal to zero
0000036D : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
0000036F : 7EF01377 : SJS : GR( F), RX( 0), DATA(1377) ! Stack IC And Jump To Subroutine
00000371 : 7EF01505 : SJS : GR( F), RX( 0), DATA(1505) ! Stack IC And Jump To Subroutine
00000373 : 707006E7 : JC : GR( 7), RX( 0), DATA( 6E7) ! Jump On Condition
000006E7 : 7EF01066 : SJS : GR( F), RX( 0), DATA(1066) ! Stack IC And Jump To Subroutine
000006E9 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
000006EB : 7A0C : BNZ : DISPL(0C) ! Branch if not equal to zero
000006F7 : 85000013 : LIM : GR( 0), RX( 0), DATA( 13) ! Single Precision Integer Load
000006F9 : 85100000 : LIM : GR( 1), RX( 0), DATA( 0) ! Single Precision Integer Load
000006FB : 85200001 : LIM : GR( 2), RX( 0), DATA( 1) ! Single Precision Integer Load
000006FD : 85300003 : LIM : GR( 3), RX( 0), DATA( 3) ! Single Precision Integer Load
000006FF : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000701 : 80002A6A : L : GR(00), RX(00), ADDR(2A6A) ! Single Precision Integer Load
00000703 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00000705 : 7A07 : BNZ : DISPL(07) ! Branch if not equal to zero
0000070C : 8F0E : POPM : GR1(00), GR2(0E) ! Pop Multiple Registers Off the Stack
0000070D : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_070E()
{
/*
0000070E : 9F06 : PSHM : GR1(00), GR2(06) ! Push Multiple Registers On Stack
0000070F : 91002A65 : STC : GR(00), RX(00), ADDR(2A65) ! Store a non negative constant
00000711 : 80002A64 : L : GR(00), RX(00), ADDR(2A64) ! Single Precision Integer Load
00000713 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00000715 : 7A32 : BNZ : DISPL(32) ! Branch if not equal to zero
00000716 : 85000008 : LIM : GR( 0), RX( 0), DATA( 8) ! Single Precision Integer Load
00000718 : 85102000 : LIM : GR( 1), RX( 0), DATA(2000) ! Single Precision Integer Load
0000071A : 85207BFF : LIM : GR( 2), RX( 0), DATA(7BFF) ! Single Precision Integer Load
0000071C : B121 : SR : GR1(02), GR2(01) ! Single Precision Integer subtract
*/
/*
0000071D : 7EF0101F : SJS : GR( F), RX( 0), DATA(101F) ! Stack IC And Jump To Subroutine
*/
subroutine_101F();
/*
0000071F : 80002A69 : L : GR(00), RX(00), ADDR(2A69) ! Single Precision Integer Load
00000721 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00000723 : 7A24 : BNZ : DISPL(24) ! Branch if not equal to zero
00000747 : 8F06 : POPM : GR1(00), GR2(06) ! Pop Multiple Registers Off the Stack
00000748 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
}
*/
void subroutine_07B2()
{
/*
000007B2 : 91006000 : STC : GR(00), RX(00), ADDR(6000) ! Store a non negative constant
000007B4 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_07B5()
{
/*
000007B5 : 9F0D : PSHM : GR1(00), GR2(0D) ! Push Multiple Registers On Stack
000007B6 : 80006000 : L : GR(00), RX(00), ADDR(6000) ! Single Precision Integer Load
000007B8 : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
000007BA : 754C : BEZ : DISPL(4C) ! Branch if equal to zero
00000806 : 8F0D : POPM : GR1(00), GR2(0D) ! Pop Multiple Registers Off the Stack
00000807 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_082F()
{
/*
0000082F : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
00000830 : 85102A6D : LIM : GR( 1), RX( 0), DATA(2A6D) ! Single Precision Integer Load
00000832 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000834 : 90010000 : ST : GR(00), RX(01), ADDR(0000) ! Single Precision Integer Store
00000836 : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
00000837 : 4A1A2A75 : CIM : GR(01), DATA(2A75) ! Single Precision Compare
00000839 : 76F9 : BLT : DISPL(F9) ! Branch if less than zero
0000083A : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
0000083B : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_083C()
{
/*
0000083C : 9F05 : PSHM : GR1(00), GR2(05) ! Push Multiple Registers On Stack
0000083D : 85400000 : LIM : GR( 4), RX( 0), DATA( 0) ! Single Precision Integer Load
0000083F : 8550000A : LIM : GR( 5), RX( 0), DATA( A) ! Single Precision Integer Load
00000841 : 6075 : SLL : GR1(07), GR2(05) ! Shift Left Logical
00000842 : 8520001A : LIM : GR( 2), RX( 0), DATA( 1A) ! Single Precision Integer Load
00000844 : 6022 : SLL : GR1(02), GR2(02) ! Shift Left Logical
00000845 : 4A280200 : ORIM : GR(02), DATA(0200) ! Inclusive Logical OR
00000847 : 8135 : LR : GR1(03), GR2(05) ! Single Precision Integer Load
00000848 : E0341624 : OR : GR(03), RX(04), ADDR(1624) ! Inclusive Logical OR
0000084A : 8702 : DLR : GR1(00), GR2(02) ! Double Precision Integer Load
0000084B : 7EF013F6 : SJS : GR( F), RX( 0), DATA(13F6) ! Stack IC And Jump To Subroutine
0000084D : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
0000084F : 750F : BEZ : DISPL(0F) ! Branch if equal to zero
00000850 : 85200005 : LIM : GR( 2), RX( 0), DATA( 5) ! Single Precision Integer Load
00000852 : 6022 : SLL : GR1(02), GR2(02) ! Shift Left Logical
00000853 : 4A280200 : ORIM : GR(02), DATA(0200) ! Inclusive Logical OR
00000855 : 8702 : DLR : GR1(00), GR2(02) ! Double Precision Integer Load
00000856 : 7EF013F6 : SJS : GR( F), RX( 0), DATA(13F6) ! Stack IC And Jump To Subroutine
00000858 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
0000085A : 7504 : BEZ : DISPL(04) ! Branch if equal to zero
0000085B : 80142A6D : L : GR(01), RX(04), ADDR(2A6D) ! Single Precision Integer Load
0000085D : 7403 : BR : DISPL(03) ! Branch Unconditionally
00000860 : 8004161C : L : GR(00), RX(04), ADDR(161C) ! Single Precision Integer Load
00000862 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000864 : A240 : AISP : RA(04), N(01) ! Single Precision Integer Add
00000865 : 4A4A0008 : CIM : GR(04), DATA(0008) ! Single Precision Compare
00000867 : 76DB : BLT : DISPL(DB) ! Branch if less than zero
00000868 : 8F05 : POPM : GR1(00), GR2(05) ! Pop Multiple Registers Off the Stack
00000869 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_086A()
{
/*
0000086A : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
0000086B : 85102A75 : LIM : GR( 1), RX( 0), DATA(2A75) ! Single Precision Integer Load
0000086D : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
0000086F : 90010000 : ST : GR(00), RX(01), ADDR(0000) ! Single Precision Integer Store
00000871 : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
00000872 : 4A1A2A7D : CIM : GR(01), DATA(2A7D) ! Single Precision Compare
00000874 : 76F9 : BLT : DISPL(F9) ! Branch if less than zero
00000875 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
00000876 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0877()
{
/*
00000877 : 9F05 : PSHM : GR1(00), GR2(05) ! Push Multiple Registers On Stack
00000878 : 85400000 : LIM : GR( 4), RX( 0), DATA( 0) ! Single Precision Integer Load
0000087A : 8550000A : LIM : GR( 5), RX( 0), DATA( A) ! Single Precision Integer Load
0000087C : 6075 : SLL : GR1(07), GR2(05) ! Shift Left Logical
0000087D : 85200007 : LIM : GR( 2), RX( 0), DATA( 7) ! Single Precision Integer Load
0000087F : 6022 : SLL : GR1(02), GR2(02) ! Shift Left Logical
00000880 : 4A280200 : ORIM : GR(02), DATA(0200) ! Inclusive Logical OR
00000882 : 8135 : LR : GR1(03), GR2(05) ! Single Precision Integer Load
00000883 : E0341634 : OR : GR(03), RX(04), ADDR(1634) ! Inclusive Logical OR
00000885 : 8702 : DLR : GR1(00), GR2(02) ! Double Precision Integer Load
00000886 : 7EF013F6 : SJS : GR( F), RX( 0), DATA(13F6) ! Stack IC And Jump To Subroutine
00000888 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
0000088A : 750F : BEZ : DISPL(0F) ! Branch if equal to zero
0000088B : 85200018 : LIM : GR( 2), RX( 0), DATA( 18) ! Single Precision Integer Load
0000088D : 6022 : SLL : GR1(02), GR2(02) ! Shift Left Logical
0000088E : 4A280200 : ORIM : GR(02), DATA(0200) ! Inclusive Logical OR
00000890 : 8702 : DLR : GR1(00), GR2(02) ! Double Precision Integer Load
00000891 : 7EF013F6 : SJS : GR( F), RX( 0), DATA(13F6) ! Stack IC And Jump To Subroutine
00000893 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00000895 : 7504 : BEZ : DISPL(04) ! Branch if equal to zero
00000896 : 80142A75 : L : GR(01), RX(04), ADDR(2A75) ! Single Precision Integer Load
00000898 : 7403 : BR : DISPL(03) ! Branch Unconditionally
0000089B : 8004162C : L : GR(00), RX(04), ADDR(162C) ! Single Precision Integer Load
0000089D : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
0000089F : A240 : AISP : RA(04), N(01) ! Single Precision Integer Add
000008A0 : 4A4A0008 : CIM : GR(04), DATA(0008) ! Single Precision Compare
000008A2 : 76DB : BLT : DISPL(DB) ! Branch if less than zero
000008A3 : 8F05 : POPM : GR1(00), GR2(05) ! Pop Multiple Registers Off the Stack
000008A4 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_08A5()
{
/*
000008A5 : 9F04 : PSHM : GR1(00), GR2(04) ! Push Multiple Registers On Stack
000008A6 : 7EF0136C : SJS : GR( F), RX( 0), DATA(136C) ! Stack IC And Jump To Subroutine
000008A8 : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
000008AA : 7A20 : BNZ : DISPL(20) ! Branch if not equal to zero
000008AB : 85300000 : LIM : GR( 3), RX( 0), DATA( 0) ! Single Precision Integer Load
000008AD : 85400000 : LIM : GR( 4), RX( 0), DATA( 0) ! Single Precision Integer Load
000008AF : 85200001 : LIM : GR( 2), RX( 0), DATA( 1) ! Single Precision Integer Load
000008B1 : 8102 : LR : GR1(00), GR2(02) ! Single Precision Integer Load
000008B2 : 7EF008CC : SJS : GR( F), RX( 0), DATA( 8CC) ! Stack IC And Jump To Subroutine
000008B4 : 7EF013F6 : SJS : GR( F), RX( 0), DATA(13F6) ! Stack IC And Jump To Subroutine
000008B6 : 6503 : DSLL : GR1(00), GR2(03) ! Double Shift Left Logical
000008B7 : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
000008B9 : 7502 : BEZ : DISPL(02) ! Branch if equal to zero
000008BB : A220 : AISP : RA(02), N(01) ! Single Precision Integer Add
000008BC : 4A2A001E : CIM : GR(02), DATA(001E) ! Single Precision Compare
000008BE : 78F3 : BLE : DISPL(F3) ! Branch if less than or equal to zero
000008BF : 6503 : DSLL : GR1(00), GR2(03) ! Double Shift Left Logical
000008C0 : 85000082 : LIM : GR( 0), RX( 0), DATA( 82) ! Single Precision Integer Load
000008C2 : 8113 : LR : GR1(01), GR2(03) ! Single Precision Integer Load
000008C3 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
000008C5 : 85000084 : LIM : GR( 0), RX( 0), DATA( 84) ! Single Precision Integer Load
000008C7 : 8114 : LR : GR1(01), GR2(04) ! Single Precision Integer Load
000008C8 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
000008CA : 8F04 : POPM : GR1(00), GR2(04) ! Pop Multiple Registers Off the Stack
000008CB : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
000008CC : 6020 : SLL : GR1(02), GR2(00) ! Shift Left Logical
000008CD : 4A080200 : ORIM : GR(00), DATA(0200) ! Inclusive Logical OR
000008CF : 8510000A : LIM : GR( 1), RX( 0), DATA( A) ! Single Precision Integer Load
000008D1 : 6071 : SLL : GR1(07), GR2(01) ! Shift Left Logical
000008D2 : 4A18000D : ORIM : GR(01), DATA(000D) ! Inclusive Logical OR
000008D4 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_08D5()
{
/*
000008D5 : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
000008D6 : 85102A7D : LIM : GR( 1), RX( 0), DATA(2A7D) ! Single Precision Integer Load
000008D8 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
000008DA : 90010000 : ST : GR(00), RX(01), ADDR(0000) ! Single Precision Integer Store
000008DC : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
000008DD : 4A1A2A85 : CIM : GR(01), DATA(2A85) ! Single Precision Compare
000008DF : 76F9 : BLT : DISPL(F9) ! Branch if less than zero
000008E0 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
000008E1 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_08E2()
{
/*
000008E2 : 9F05 : PSHM : GR1(00), GR2(05) ! Push Multiple Registers On Stack
000008E3 : 85400000 : LIM : GR( 4), RX( 0), DATA( 0) ! Single Precision Integer Load
000008E5 : 8550000A : LIM : GR( 5), RX( 0), DATA( A) ! Single Precision Integer Load
000008E7 : 6075 : SLL : GR1(07), GR2(05) ! Shift Left Logical
000008E8 : 85200004 : LIM : GR( 2), RX( 0), DATA( 4) ! Single Precision Integer Load
000008EA : 6022 : SLL : GR1(02), GR2(02) ! Shift Left Logical
000008EB : 4A280200 : ORIM : GR(02), DATA(0200) ! Inclusive Logical OR
000008ED : 8135 : LR : GR1(03), GR2(05) ! Single Precision Integer Load
000008EE : E0341644 : OR : GR(03), RX(04), ADDR(1644) ! Inclusive Logical OR
000008F0 : 8702 : DLR : GR1(00), GR2(02) ! Double Precision Integer Load
000008F1 : 7EF013F6 : SJS : GR( F), RX( 0), DATA(13F6) ! Stack IC And Jump To Subroutine
000008F3 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
000008F5 : 750F : BEZ : DISPL(0F) ! Branch if equal to zero
000008F6 : 8520001B : LIM : GR( 2), RX( 0), DATA( 1B) ! Single Precision Integer Load
000008F8 : 6022 : SLL : GR1(02), GR2(02) ! Shift Left Logical
000008F9 : 4A280200 : ORIM : GR(02), DATA(0200) ! Inclusive Logical OR
000008FB : 8702 : DLR : GR1(00), GR2(02) ! Double Precision Integer Load
000008FC : 7EF013F6 : SJS : GR( F), RX( 0), DATA(13F6) ! Stack IC And Jump To Subroutine
000008FE : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00000900 : 7504 : BEZ : DISPL(04) ! Branch if equal to zero
00000901 : 80142A7D : L : GR(01), RX(04), ADDR(2A7D) ! Single Precision Integer Load
00000903 : 7403 : BR : DISPL(03) ! Branch Unconditionally
00000906 : 8004163C : L : GR(00), RX(04), ADDR(163C) ! Single Precision Integer Load
00000908 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
0000090A : A240 : AISP : RA(04), N(01) ! Single Precision Integer Add
0000090B : 4A4A0008 : CIM : GR(04), DATA(0008) ! Single Precision Compare
0000090D : 76DB : BLT : DISPL(DB) ! Branch if less than zero
0000090E : 8F05 : POPM : GR1(00), GR2(05) ! Pop Multiple Registers Off the Stack
0000090F : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0910()
{
/*
00000910 : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
00000911 : 85000003 : LIM : GR( 0), RX( 0), DATA( 3) ! Single Precision Integer Load
00000913 : 90002B92 : ST : GR(00), RX(00), ADDR(2B92) ! Single Precision Integer Store
00000915 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000917 : 85102B98 : LIM : GR( 1), RX( 0), DATA(2B98) ! Single Precision Integer Load
00000919 : 4A1A2BA9 : CIM : GR(01), DATA(2BA9) ! Single Precision Compare
0000091B : 7905 : BGT : DISPL(05) ! Branch if greater than zero
0000091C : 91010000 : STC : GR(00), RX(01), ADDR(0000) ! Store a non negative constant
0000091E : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
0000091F : 74FA : BR : DISPL(FA) ! Branch Unconditionally
00000920 : 91002B8E : STC : GR(00), RX(00), ADDR(2B8E) ! Store a non negative constant
00000922 : 91002B8F : STC : GR(00), RX(00), ADDR(2B8F) ! Store a non negative constant
00000924 : 91002B90 : STC : GR(00), RX(00), ADDR(2B90) ! Store a non negative constant
00000926 : 91002B91 : STC : GR(00), RX(00), ADDR(2B91) ! Store a non negative constant
00000928 : 91002B96 : STC : GR(00), RX(00), ADDR(2B96) ! Store a non negative constant
0000092A : 85000001 : LIM : GR( 0), RX( 0), DATA( 1) ! Single Precision Integer Load
0000092C : 90002B95 : ST : GR(00), RX(00), ADDR(2B95) ! Single Precision Integer Store
0000092E : 85000003 : LIM : GR( 0), RX( 0), DATA( 3) ! Single Precision Integer Load
00000930 : 90002B97 : ST : GR(00), RX(00), ADDR(2B97) ! Single Precision Integer Store
00000932 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
00000933 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
/*
*
*/
void subroutine_0934()
{
/*
00000934 : 9F07 : PSHM : GR1(00), GR2(07) ! Push Multiple Registers On Stack
00000935 : 85600000 : LIM : GR( 6), RX( 0), DATA( 0) ! Single Precision Integer Load
00000937 : 90602B93 : ST : GR(06), RX(00), ADDR(2B93) ! Single Precision Integer Store
00000939 : 90602B94 : ST : GR(06), RX(00), ADDR(2B94) ! Single Precision Integer Store
0000093B : 85400000 : LIM : GR( 4), RX( 0), DATA( 0) ! Single Precision Integer Load
0000093D : 4A4A0001 : CIM : GR(04), DATA(0001) ! Single Precision Compare
0000093F : 7964 : BGT : DISPL(64) ! Branch if greater than zero
00000940 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000942 : 4A4A0000 : CIM : GR(04), DATA(0000) ! Single Precision Compare
00000944 : 7A0F : BNZ : DISPL(0F) ! Branch if not equal to zero
00000945 : 85700001 : LIM : GR( 7), RX( 0), DATA( 1) ! Single Precision Integer Load
00000947 : E2702B97 : AND : GR(07), RX(00), ADDR(2B97) ! Logical AND
00000949 : 7509 : BEZ : DISPL(09) ! Branch if equal to zero
0000094A : 80007F00 : L : GR(00), RX(00), ADDR(7F00) ! Single Precision Integer Load
0000094C : 80107F01 : L : GR(01), RX(00), ADDR(7F01) ! Single Precision Integer Load
0000094E : 80207F02 : L : GR(02), RX(00), ADDR(7F02) ! Single Precision Integer Load
00000950 : 80307F03 : L : GR(03), RX(00), ADDR(7F03) ! Single Precision Integer Load
00000952 : 740E : BR : DISPL(0E) ! Branch Unconditionally
00000953 : 85700002 : LIM : GR( 7), RX( 0), DATA( 2) ! Single Precision Integer Load
00000955 : E2702B97 : AND : GR(07), RX(00), ADDR(2B97) ! Logical AND
00000957 : 7509 : BEZ : DISPL(09) ! Branch if equal to zero
00000958 : 80007F40 : L : GR(00), RX(00), ADDR(7F40) ! Single Precision Integer Load
0000095A : 80107F41 : L : GR(01), RX(00), ADDR(7F41) ! Single Precision Integer Load
0000095C : 80207F42 : L : GR(02), RX(00), ADDR(7F42) ! Single Precision Integer Load
0000095E : 80307F43 : L : GR(03), RX(00), ADDR(7F43) ! Single Precision Integer Load
00000960 : 8150 : LR : GR1(05), GR2(00) ! Single Precision Integer Load
00000961 : 4A57E000 : ANDM : GR(05), DATA(E000) ! Logical AND
00000963 : 4A5AE000 : CIM : GR(05), DATA(E000) ! Single Precision Compare
00000965 : 7A06 : BNZ : DISPL(06) ! Branch if not equal to zero
0000096B : 4A5A2000 : CIM : GR(05), DATA(2000) ! Single Precision Compare
0000096D : 7A0A : BNZ : DISPL(0A) ! Branch if not equal to zero
00000977 : 4A5A4000 : CIM : GR(05), DATA(4000) ! Single Precision Compare
00000979 : 7A0A : BNZ : DISPL(0A) ! Branch if not equal to zero
00000983 : 4A5A8000 : CIM : GR(05), DATA(8000) ! Single Precision Compare
00000985 : 7A0A : BNZ : DISPL(0A) ! Branch if not equal to zero
0000098F : 4A5A0000 : CIM : GR(05), DATA(0000) ! Single Precision Compare
00000991 : 7A04 : BNZ : DISPL(04) ! Branch if not equal to zero
00000992 : 90542B93 : ST : GR(05), RX(04), ADDR(2B93) ! Single Precision Integer Store
00000994 : 740D : BR : DISPL(0D) ! Branch Unconditionally
000009A1 : A240 : AISP : RA(04), N(01) ! Single Precision Integer Add
000009A2 : 749B : BR : DISPL(9B) ! Branch Unconditionally
000009A3 : 80602B93 : L : GR(06), RX(00), ADDR(2B93) ! Single Precision Integer Load
000009A5 : F0602B94 : C : GR(06), RX(00), ADDR(2B94) ! Single Precision Compare
000009A7 : 7A08 : BNZ : DISPL(08) ! Branch if not equal to zero
000009A8 : 4A6AE000 : CIM : GR(06), DATA(E000) ! Single Precision Compare
000009AA : 7A05 : BNZ : DISPL(05) ! Branch if not equal to zero
000009AF : 8F07 : POPM : GR1(00), GR2(07) ! Pop Multiple Registers Off the Stack
000009B0 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
/*
*
*/
void subroutine_09B1()
{
/*
000009B1 : 9F24 : PSHM : GR1(02), GR2(04) ! Push Multiple Registers On Stack
000009B2 : 7EF014FC : SJS : GR( F), RX( 0), DATA(14FC) ! Stack IC And Jump To Subroutine
000009B4 : 8120 : LR : GR1(02), GR2(00) ! Single Precision Integer Load
000009B5 : 7EF00B77 : SJS : GR( F), RX( 0), DATA( B77) ! Stack IC And Jump To Subroutine
000009B7 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
000009B9 : 7A06 : BNZ : DISPL(06) ! Branch if not equal to zero
000009BA : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
000009BC : 85100000 : LIM : GR( 1), RX( 0), DATA( 0) ! Single Precision Integer Load
000009BE : 7415 : BR : DISPL(15) ! Branch Unconditionally
000009D3 : 7EF01505 : SJS : GR( F), RX( 0), DATA(1505) ! Stack IC And Jump To Subroutine
000009D5 : 8F24 : POPM : GR1(02), GR2(04) ! Pop Multiple Registers Off the Stack
000009D6 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_09D7()
{
/*
000009D7 : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
000009D8 : 80002B95 : L : GR(00), RX(00), ADDR(2B95) ! Single Precision Integer Load
000009DA : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
000009DC : 7A10 : BNZ : DISPL(10) ! Branch if not equal to zero
000009DD : 850001FA : LIM : GR( 0), RX( 0), DATA( 1FA) ! Single Precision Integer Load
000009DF : 85100100 : LIM : GR( 1), RX( 0), DATA( 100) ! Single Precision Integer Load
000009E1 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
000009E3 : 850001FC : LIM : GR( 0), RX( 0), DATA( 1FC) ! Single Precision Integer Load
000009E5 : 80102BA8 : L : GR(01), RX(00), ADDR(2BA8) ! Single Precision Integer Load
000009E7 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
000009E9 : 91002B95 : STC : GR(00), RX(00), ADDR(2B95) ! Store a non negative constant
000009EB : 740F : BR : DISPL(0F) ! Branch Unconditionally
000009EC : 850001FA : LIM : GR( 0), RX( 0), DATA( 1FA) ! Single Precision Integer Load
000009EE : 8510011C : LIM : GR( 1), RX( 0), DATA( 11C) ! Single Precision Integer Load
000009F0 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
000009F2 : 850001FC : LIM : GR( 0), RX( 0), DATA( 1FC) ! Single Precision Integer Load
000009F4 : 80102BA9 : L : GR(01), RX(00), ADDR(2BA9) ! Single Precision Integer Load
000009F6 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
000009F8 : 91102B95 : STC : GR(01), RX(00), ADDR(2B95) ! Store a non negative constant
000009FA : 7EF0136C : SJS : GR( F), RX( 0), DATA(136C) ! Stack IC And Jump To Subroutine
000009FC : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
000009FE : 7A66 : BNZ : DISPL(66) ! Branch if not equal to zero
000009FF : 7EF01374 : SJS : GR( F), RX( 0), DATA(1374) ! Stack IC And Jump To Subroutine
00000A01 : 4A0A0000 : CIM : GR(00), DATA(0000) ! Single Precision Compare
00000A03 : 7A61 : BNZ : DISPL(61) ! Branch if not equal to zero
00000A04 : 85000062 : LIM : GR( 0), RX( 0), DATA( 62) ! Single Precision Integer Load
00000A06 : 80102B98 : L : GR(01), RX(00), ADDR(2B98) ! Single Precision Integer Load
00000A08 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A0A : 85000064 : LIM : GR( 0), RX( 0), DATA( 64) ! Single Precision Integer Load
00000A0C : 80102B9A : L : GR(01), RX(00), ADDR(2B9A) ! Single Precision Integer Load
00000A0E : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A10 : 85000066 : LIM : GR( 0), RX( 0), DATA( 66) ! Single Precision Integer Load
00000A12 : 80102B9C : L : GR(01), RX(00), ADDR(2B9C) ! Single Precision Integer Load
00000A14 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A16 : 85000068 : LIM : GR( 0), RX( 0), DATA( 68) ! Single Precision Integer Load
00000A18 : 80102B9E : L : GR(01), RX(00), ADDR(2B9E) ! Single Precision Integer Load
00000A1A : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A1C : 8500006A : LIM : GR( 0), RX( 0), DATA( 6A) ! Single Precision Integer Load
00000A1E : 80102BA0 : L : GR(01), RX(00), ADDR(2BA0) ! Single Precision Integer Load
00000A20 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A22 : 8500006C : LIM : GR( 0), RX( 0), DATA( 6C) ! Single Precision Integer Load
00000A24 : 80102BA2 : L : GR(01), RX(00), ADDR(2BA2) ! Single Precision Integer Load
00000A26 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A28 : 8500006E : LIM : GR( 0), RX( 0), DATA( 6E) ! Single Precision Integer Load
00000A2A : 80102BA4 : L : GR(01), RX(00), ADDR(2BA4) ! Single Precision Integer Load
00000A2C : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A2E : 85000070 : LIM : GR( 0), RX( 0), DATA( 70) ! Single Precision Integer Load
00000A30 : 80102BA6 : L : GR(01), RX(00), ADDR(2BA6) ! Single Precision Integer Load
00000A32 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A34 : 85000072 : LIM : GR( 0), RX( 0), DATA( 72) ! Single Precision Integer Load
00000A36 : 80102B99 : L : GR(01), RX(00), ADDR(2B99) ! Single Precision Integer Load
00000A38 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A3A : 85000074 : LIM : GR( 0), RX( 0), DATA( 74) ! Single Precision Integer Load
00000A3C : 80102B9B : L : GR(01), RX(00), ADDR(2B9B) ! Single Precision Integer Load
00000A3E : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A40 : 85000076 : LIM : GR( 0), RX( 0), DATA( 76) ! Single Precision Integer Load
00000A42 : 80102B9D : L : GR(01), RX(00), ADDR(2B9D) ! Single Precision Integer Load
00000A44 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A46 : 85000078 : LIM : GR( 0), RX( 0), DATA( 78) ! Single Precision Integer Load
00000A48 : 80102B9F : L : GR(01), RX(00), ADDR(2B9F) ! Single Precision Integer Load
00000A4A : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A4C : 8500007A : LIM : GR( 0), RX( 0), DATA( 7A) ! Single Precision Integer Load
00000A4E : 80102BA1 : L : GR(01), RX(00), ADDR(2BA1) ! Single Precision Integer Load
00000A50 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A52 : 8500007C : LIM : GR( 0), RX( 0), DATA( 7C) ! Single Precision Integer Load
00000A54 : 80102BA3 : L : GR(01), RX(00), ADDR(2BA3) ! Single Precision Integer Load
00000A56 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A58 : 8500007E : LIM : GR( 0), RX( 0), DATA( 7E) ! Single Precision Integer Load
00000A5A : 80102BA5 : L : GR(01), RX(00), ADDR(2BA5) ! Single Precision Integer Load
00000A5C : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A5E : 85000080 : LIM : GR( 0), RX( 0), DATA( 80) ! Single Precision Integer Load
00000A60 : 80102BA7 : L : GR(01), RX(00), ADDR(2BA7) ! Single Precision Integer Load
00000A62 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000A64 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
00000A65 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0B77()
{
/*
00000B77 : 9F11 : PSHM : GR1(01), GR2(01) ! Push Multiple Registers On Stack
00000B78 : 80102B8E : L : GR(01), RX(00), ADDR(2B8E) ! Single Precision Integer Load
00000B7A : F0102B90 : C : GR(01), RX(00), ADDR(2B90) ! Single Precision Compare
00000B7C : 7A04 : BNZ : DISPL(04) ! Branch if not equal to zero
00000B7D : 85000001 : LIM : GR( 0), RX( 0), DATA( 1) ! Single Precision Integer Load
00000B7F : 7403 : BR : DISPL(03) ! Branch Unconditionally
00000B82 : 8F11 : POPM : GR1(01), GR2(01) ! Pop Multiple Registers Off the Stack
00000B83 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0B84()
{
/*
00000B84 : 9F00 : PSHM : GR1(00), GR2(00) ! Push Multiple Registers On Stack
00000B85 : 85000003 : LIM : GR( 0), RX( 0), DATA( 3) ! Single Precision Integer Load
00000B87 : 9000302C : ST : GR(00), RX(00), ADDR(302C) ! Single Precision Integer Store
00000B89 : 9100302D : STC : GR(00), RX(00), ADDR(302D) ! Store a non negative constant
00000B8B : 9100302F : STC : GR(00), RX(00), ADDR(302F) ! Store a non negative constant
00000B8D : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000B8F : 9000302E : ST : GR(00), RX(00), ADDR(302E) ! Single Precision Integer Store
00000B91 : 91003030 : STC : GR(00), RX(00), ADDR(3030) ! Store a non negative constant
00000B93 : 9100302B : STC : GR(00), RX(00), ADDR(302B) ! Store a non negative constant
00000B95 : 91002FAD : STC : GR(00), RX(00), ADDR(2FAD) ! Store a non negative constant
00000B97 : 8F00 : POPM : GR1(00), GR2(00) ! Pop Multiple Registers Off the Stack
00000B98 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0B99()
{
/*
00000B99 : 9F04 : PSHM : GR1(00), GR2(04) ! Push Multiple Registers On Stack
00000B9A : 85002FAE : LIM : GR( 0), RX( 0), DATA(2FAE) ! Single Precision Integer Load
00000B9C : 7EF009B1 : SJS : GR( F), RX( 0), DATA( 9B1) ! Stack IC And Jump To Subroutine
00000B9E : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00000BA0 : 7A5C : BNZ : DISPL(5C) ! Branch if not equal to zero
00000BFC : 8F04 : POPM : GR1(00), GR2(04) ! Pop Multiple Registers Off the Stack
00000BFD : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0BFE()
{
/*
00000BFE : 9F03 : PSHM : GR1(00), GR2(03) ! Push Multiple Registers On Stack
00000BFF : 85000021 : LIM : GR( 0), RX( 0), DATA( 21) ! Single Precision Integer Load
00000C01 : 80103030 : L : GR(01), RX(00), ADDR(3030) ! Single Precision Integer Load
00000C03 : 85200006 : LIM : GR( 2), RX( 0), DATA( 6) ! Single Precision Integer Load
00000C05 : 85300000 : LIM : GR( 3), RX( 0), DATA( 0) ! Single Precision Integer Load
00000C07 : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000C09 : 85000021 : LIM : GR( 0), RX( 0), DATA( 21) ! Single Precision Integer Load
00000C0B : 8010302E : L : GR(01), RX(00), ADDR(302E) ! Single Precision Integer Load
00000C0D : 85200001 : LIM : GR( 2), RX( 0), DATA( 1) ! Single Precision Integer Load
00000C0F : 85300006 : LIM : GR( 3), RX( 0), DATA( 6) ! Single Precision Integer Load
00000C11 : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000C13 : 85000021 : LIM : GR( 0), RX( 0), DATA( 21) ! Single Precision Integer Load
00000C15 : 8010302D : L : GR(01), RX(00), ADDR(302D) ! Single Precision Integer Load
00000C17 : 85200001 : LIM : GR( 2), RX( 0), DATA( 1) ! Single Precision Integer Load
00000C19 : 85300007 : LIM : GR( 3), RX( 0), DATA( 7) ! Single Precision Integer Load
00000C1B : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000C1D : 8F03 : POPM : GR1(00), GR2(03) ! Pop Multiple Registers Off the Stack
00000C1E : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0C94()
{
/*
00000C94 : 9F00 : PSHM : GR1(00), GR2(00) ! Push Multiple Registers On Stack
00000C95 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000C97 : 90003034 : ST : GR(00), RX(00), ADDR(3034) ! Single Precision Integer Store
00000C99 : 91003032 : STC : GR(00), RX(00), ADDR(3032) ! Store a non negative constant
00000C9B : 91003033 : STC : GR(00), RX(00), ADDR(3033) ! Store a non negative constant
00000C9D : 85000001 : LIM : GR( 0), RX( 0), DATA( 1) ! Single Precision Integer Load
00000C9F : 90003035 : ST : GR(00), RX(00), ADDR(3035) ! Single Precision Integer Store
00000CA1 : 91003036 : STC : GR(00), RX(00), ADDR(3036) ! Store a non negative constant
00000CA3 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000CA5 : 90003031 : ST : GR(00), RX(00), ADDR(3031) ! Single Precision Integer Store
00000CA7 : 8F00 : POPM : GR1(00), GR2(00) ! Pop Multiple Registers Off the Stack
00000CA8 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0D9A()
{
/*
00000D9A : 9F03 : PSHM : GR1(00), GR2(03) ! Push Multiple Registers On Stack
00000D9B : 8500001E : LIM : GR( 0), RX( 0), DATA( 1E) ! Single Precision Integer Load
00000D9D : 80103031 : L : GR(01), RX(00), ADDR(3031) ! Single Precision Integer Load
00000D9F : 85200004 : LIM : GR( 2), RX( 0), DATA( 4) ! Single Precision Integer Load
00000DA1 : 8530000C : LIM : GR( 3), RX( 0), DATA( C) ! Single Precision Integer Load
00000DA3 : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000DA5 : 8500001E : LIM : GR( 0), RX( 0), DATA( 1E) ! Single Precision Integer Load
00000DA7 : 80103032 : L : GR(01), RX(00), ADDR(3032) ! Single Precision Integer Load
00000DA9 : 8520000B : LIM : GR( 2), RX( 0), DATA( B) ! Single Precision Integer Load
00000DAB : 85300000 : LIM : GR( 3), RX( 0), DATA( 0) ! Single Precision Integer Load
00000DAD : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000DAF : 85000020 : LIM : GR( 0), RX( 0), DATA( 20) ! Single Precision Integer Load
00000DB1 : 80103033 : L : GR(01), RX(00), ADDR(3033) ! Single Precision Integer Load
00000DB3 : 7EF01393 : SJS : GR( F), RX( 0), DATA(1393) ! Stack IC And Jump To Subroutine
00000DB5 : 85000014 : LIM : GR( 0), RX( 0), DATA( 14) ! Single Precision Integer Load
00000DB7 : 80103034 : L : GR(01), RX(00), ADDR(3034) ! Single Precision Integer Load
00000DB9 : 85200001 : LIM : GR( 2), RX( 0), DATA( 1) ! Single Precision Integer Load
00000DBB : 8530000A : LIM : GR( 3), RX( 0), DATA( A) ! Single Precision Integer Load
00000DBD : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000DBF : 85000014 : LIM : GR( 0), RX( 0), DATA( 14) ! Single Precision Integer Load
00000DC1 : 80103035 : L : GR(01), RX(00), ADDR(3035) ! Single Precision Integer Load
00000DC3 : 85200001 : LIM : GR( 2), RX( 0), DATA( 1) ! Single Precision Integer Load
00000DC5 : 85300009 : LIM : GR( 3), RX( 0), DATA( 9) ! Single Precision Integer Load
00000DC7 : 7EF013C7 : SJS : GR( F), RX( 0), DATA(13C7) ! Stack IC And Jump To Subroutine
00000DC9 : 8500001D : LIM : GR( 0), RX( 0), DATA( 1D) ! Single Precision Integer Load
00000DCB : 80103036 : L : GR(01), RX(00), ADDR(3036) ! Single Precision Integer Load
00000DCD : 7EF01386 : SJS : GR( F), RX( 0), DATA(1386) ! Stack IC And Jump To Subroutine
00000DCF : 8F03 : POPM : GR1(00), GR2(03) ! Pop Multiple Registers Off the Stack
00000DD0 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0E29()
{
/*
00000E29 : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
00000E2A : 85100000 : LIM : GR( 1), RX( 0), DATA( 0) ! Single Precision Integer Load
00000E2C : 4A1A0100 : CIM : GR(01), DATA(0100) ! Single Precision Compare
00000E2E : 7B27 : BGE : DISPL(27) ! Branch if greater than or equal to zero
00000E2F : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00000E31 : 57F1 : TBR : GR1(0F), GR2(01) ! Test Bit
00000E32 : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E33 : 4A091021 : XORM : GR(00), DATA(1021) ! Exlusive Logical OR
00000E35 : 57E1 : TBR : GR1(0E), GR2(01) ! Test Bit
00000E36 : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E37 : 4A092042 : XORM : GR(00), DATA(2042) ! Exlusive Logical OR
00000E39 : 57D1 : TBR : GR1(0D), GR2(01) ! Test Bit
00000E3A : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E3B : 4A094084 : XORM : GR(00), DATA(4084) ! Exlusive Logical OR
00000E3D : 57C1 : TBR : GR1(0C), GR2(01) ! Test Bit
00000E3E : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E3F : 4A098108 : XORM : GR(00), DATA(8108) ! Exlusive Logical OR
00000E41 : 57B1 : TBR : GR1(0B), GR2(01) ! Test Bit
00000E42 : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E43 : 4A091231 : XORM : GR(00), DATA(1231) ! Exlusive Logical OR
00000E45 : 57A1 : TBR : GR1(0A), GR2(01) ! Test Bit
00000E46 : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E47 : 4A092462 : XORM : GR(00), DATA(2462) ! Exlusive Logical OR
00000E49 : 5791 : TBR : GR1(09), GR2(01) ! Test Bit
00000E4A : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E4B : 4A0948C4 : XORM : GR(00), DATA(48C4) ! Exlusive Logical OR
00000E4D : 5781 : TBR : GR1(08), GR2(01) ! Test Bit
00000E4E : 7503 : BEZ : DISPL(03) ! Branch if equal to zero
00000E4F : 4A099188 : XORM : GR(00), DATA(9188) ! Exlusive Logical OR
00000E51 : 9001303A : ST : GR(00), RX(01), ADDR(303A) ! Single Precision Integer Store
00000E53 : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
00000E54 : 74D8 : BR : DISPL(D8) ! Branch Unconditionally
00000E55 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
00000E56 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_0E57()
{
/*
00000E57 : 9F1C : PSHM : GR1(01), GR2(0C) ! Push Multiple Registers On Stack
00000E58 : 85C00000 : LIM : GR( C), RX( 0), DATA( 0) ! Single Precision Integer Load
00000E5A : 8132 : LR : GR1(03), GR2(02) ! Single Precision Integer Load
00000E5B : F1C3 : CR : GR1(0C), GR2(03) ! Single Precision Compare
00000E5C : 7B1E : BGE : DISPL(1E) ! Branch if greater than or equal to zero
00000E5D : 4001 : LBX : BR(C), X(0), RX(1) ! Single Precision Integer Load
00000E5E : 6172 : SRL : GR1(07), GR2(02) ! Shift Right Logical
00000E5F : 8150 : LR : GR1(05), GR2(00) ! Single Precision Integer Load
00000E60 : 6175 : SRL : GR1(07), GR2(05) ! Shift Right Logical
00000E61 : E552 : XORR : GR1(05), GR2(02) ! Exclusive Logical OR
00000E62 : 4A5700FF : ANDM : GR(05), DATA(00FF) ! Logical AND
00000E64 : 8045303A : L : GR(04), RX(05), ADDR(303A) ! Single Precision Integer Load
00000E66 : 8150 : LR : GR1(05), GR2(00) ! Single Precision Integer Load
00000E67 : 6075 : SLL : GR1(07), GR2(05) ! Shift Left Logical
00000E68 : E554 : XORR : GR1(05), GR2(04) ! Exclusive Logical OR
00000E69 : 8105 : LR : GR1(00), GR2(05) ! Single Precision Integer Load
00000E6A : 4001 : LBX : BR(C), X(0), RX(1) ! Single Precision Integer Load
00000E6B : 4A2700FF : ANDM : GR(02), DATA(00FF) ! Logical AND
00000E6D : 8150 : LR : GR1(05), GR2(00) ! Single Precision Integer Load
00000E6E : 6175 : SRL : GR1(07), GR2(05) ! Shift Right Logical
00000E6F : E552 : XORR : GR1(05), GR2(02) ! Exclusive Logical OR
00000E70 : 4A5700FF : ANDM : GR(05), DATA(00FF) ! Logical AND
00000E72 : 8045303A : L : GR(04), RX(05), ADDR(303A) ! Single Precision Integer Load
00000E74 : 8150 : LR : GR1(05), GR2(00) ! Single Precision Integer Load
00000E75 : 6075 : SLL : GR1(07), GR2(05) ! Shift Left Logical
00000E76 : E554 : XORR : GR1(05), GR2(04) ! Exclusive Logical OR
00000E77 : 8105 : LR : GR1(00), GR2(05) ! Single Precision Integer Load
00000E78 : A2C0 : AISP : RA(0C), N(01) ! Single Precision Integer Add
00000E79 : 74E2 : BR : DISPL(E2) ! Branch Unconditionally
00000E7A : 8F1C : POPM : GR1(01), GR2(0C) ! Pop Multiple Registers Off the Stack
00000E7B : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
0000101C : 91003146 : STC : GR(00), RX(00), ADDR(3146) ! Store a non negative constant
0000101E : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_101F()
{
/*
0000101F : 9F0C : PSHM : GR1(00), GR2(0C) ! Push Multiple Registers On Stack
00001020 : 7EF01277 : SJS : GR( F), RX( 0), DATA(1277) ! Stack IC And Jump To Subroutine
00001022 : 48C0A00E : XIO : GR( C), RX( 0), DATA(A00E) ! Execute Input/Output
00001024 : 8150 : LR : GR1(05), GR2(00) ! Single Precision Integer Load
00001025 : 8170 : LR : GR1(07), GR2(00) ! Single Precision Integer Load
00001026 : A172 : AR : GR1(07), GR2(02) ! Single Precision Integer add
00001027 : 80003146 : L : GR(00), RX(00), ADDR(3146) ! Single Precision Integer Load
00001029 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
0000102B : 7526 : BEZ : DISPL(26) ! Branch if equal to zero
0000102C : 81A5 : LR : GR1(0A), GR2(05) ! Single Precision Integer Load
0000102D : 80BA0000 : L : GR(0B), RX(0A), ADDR(0000) ! Single Precision Integer Load
0000102F : 80907FA1 : L : GR(09), RX(00), ADDR(7FA1) ! Single Precision Integer Load
00001031 : 4A970200 : ANDM : GR(09), DATA(0200) ! Logical AND
00001033 : 751B : BEZ : DISPL(1B) ! Branch if equal to zero
0000104E : A250 : AISP : RA(05), N(01) ! Single Precision Integer Add
0000104F : F157 : CR : GR1(05), GR2(07) ! Single Precision Compare
00001050 : 78D7 : BLE : DISPL(D7) ! Branch if less than or equal to zero
00001051 : 8F0C : POPM : GR1(00), GR2(0C) ! Pop Multiple Registers Off the Stack
00001052 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_1056()
{
/*
00001056 : 9F00 : PSHM : GR1(00), GR2(00) ! Push Multiple Registers On Stack
00001057 : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
00001059 : 7A06 : BNZ : DISPL(06) ! Branch if not equal to zero
0000105F : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00001061 : 48006002 : XIO : GR( 0), RX( 0), DATA(6002) ! Execute Input/Output
00001063 : 7401 : BR : DISPL(01) ! Branch Unconditionally
00001064 : 8F00 : POPM : GR1(00), GR2(00) ! Pop Multiple Registers Off the Stack
00001065 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
00001066 : 4800E002 : XIO : GR( 0), RX( 0), DATA(E002) ! Execute Input/Output
00001068 : 4A070001 : ANDM : GR(00), DATA(0001) ! Logical AND
0000106A : 4A0A0001 : CIM : GR(00), DATA(0001) ! Single Precision Compare
0000106C : 7A04 : BNZ : DISPL(04) ! Branch if not equal to zero
00001070 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00001072 : 7401 : BR : DISPL(01) ! Branch Unconditionally
00001073 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_121E()
{
/*
0000121E : 9F01 : PSHM : GR1(00), GR2(01) ! Push Multiple Registers On Stack
0000121F : 85000010 : LIM : GR( 0), RX( 0), DATA( 10) ! Single Precision Integer Load
00001221 : 85100001 : LIM : GR( 1), RX( 0), DATA( 1) ! Single Precision Integer Load
00001223 : 4A1A0010 : CIM : GR(01), DATA(0010) ! Single Precision Compare
00001225 : 7B05 : BGE : DISPL(05) ! Branch if greater than or equal to zero
00001226 : 48015110 : XIO : GR( 0), RX( 1), DATA(5110) ! Execute Input/Output
00001228 : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
00001229 : 74FA : BR : DISPL(FA) ! Branch Unconditionally
0000122A : 85000050 : LIM : GR( 0), RX( 0), DATA( 50) ! Single Precision Integer Load
0000122C : 85100001 : LIM : GR( 1), RX( 0), DATA( 1) ! Single Precision Integer Load
0000122E : 4A1A0010 : CIM : GR(01), DATA(0010) ! Single Precision Compare
00001230 : 7B05 : BGE : DISPL(05) ! Branch if greater than or equal to zero
00001231 : 48015150 : XIO : GR( 0), RX( 1), DATA(5150) ! Execute Input/Output
00001233 : A210 : AISP : RA(01), N(01) ! Single Precision Integer Add
00001234 : 74FA : BR : DISPL(FA) ! Branch Unconditionally
00001235 : 85000000 : LIM : GR( 0), RX( 0), DATA( 0) ! Single Precision Integer Load
00001237 : 48005170 : XIO : GR( 0), RX( 0), DATA(5170) ! Execute Input/Output
00001239 : 85000001 : LIM : GR( 0), RX( 0), DATA( 1) ! Single Precision Integer Load
0000123B : 48005171 : XIO : GR( 0), RX( 0), DATA(5171) ! Execute Input/Output
0000123D : 85000002 : LIM : GR( 0), RX( 0), DATA( 2) ! Single Precision Integer Load
0000123F : 48005172 : XIO : GR( 0), RX( 0), DATA(5172) ! Execute Input/Output
00001241 : 85000003 : LIM : GR( 0), RX( 0), DATA( 3) ! Single Precision Integer Load
00001243 : 48005173 : XIO : GR( 0), RX( 0), DATA(5173) ! Execute Input/Output
00001245 : 85000004 : LIM : GR( 0), RX( 0), DATA( 4) ! Single Precision Integer Load
00001247 : 48005174 : XIO : GR( 0), RX( 0), DATA(5174) ! Execute Input/Output
00001249 : 85000005 : LIM : GR( 0), RX( 0), DATA( 5) ! Single Precision Integer Load
0000124B : 48005175 : XIO : GR( 0), RX( 0), DATA(5175) ! Execute Input/Output
0000124D : 85000006 : LIM : GR( 0), RX( 0), DATA( 6) ! Single Precision Integer Load
0000124F : 48005176 : XIO : GR( 0), RX( 0), DATA(5176) ! Execute Input/Output
00001251 : 85000020 : LIM : GR( 0), RX( 0), DATA( 20) ! Single Precision Integer Load
00001253 : 48005177 : XIO : GR( 0), RX( 0), DATA(5177) ! Execute Input/Output
00001255 : 85000021 : LIM : GR( 0), RX( 0), DATA( 21) ! Single Precision Integer Load
00001257 : 48005178 : XIO : GR( 0), RX( 0), DATA(5178) ! Execute Input/Output
00001259 : 85000022 : LIM : GR( 0), RX( 0), DATA( 22) ! Single Precision Integer Load
0000125B : 48005179 : XIO : GR( 0), RX( 0), DATA(5179) ! Execute Input/Output
0000125D : 85000023 : LIM : GR( 0), RX( 0), DATA( 23) ! Single Precision Integer Load
0000125F : 4800517A : XIO : GR( 0), RX( 0), DATA(517A) ! Execute Input/Output
00001261 : 85000024 : LIM : GR( 0), RX( 0), DATA( 24) ! Single Precision Integer Load
00001263 : 4800517B : XIO : GR( 0), RX( 0), DATA(517B) ! Execute Input/Output
00001265 : 85000025 : LIM : GR( 0), RX( 0), DATA( 25) ! Single Precision Integer Load
00001267 : 4800517C : XIO : GR( 0), RX( 0), DATA(517C) ! Execute Input/Output
00001269 : 85000026 : LIM : GR( 0), RX( 0), DATA( 26) ! Single Precision Integer Load
0000126B : 4800517D : XIO : GR( 0), RX( 0), DATA(517D) ! Execute Input/Output
0000126D : 85000030 : LIM : GR( 0), RX( 0), DATA( 30) ! Single Precision Integer Load
0000126F : 4800517E : XIO : GR( 0), RX( 0), DATA(517E) ! Execute Input/Output
00001271 : 8500003F : LIM : GR( 0), RX( 0), DATA( 3F) ! Single Precision Integer Load
00001273 : 4800517F : XIO : GR( 0), RX( 0), DATA(517F) ! Execute Input/Output
00001275 : 8F01 : POPM : GR1(00), GR2(01) ! Pop Multiple Registers Off the Stack
00001276 : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine
*/
}
void subroutine_1277()
{
/*
00001277 : 9F12 : PSHM : GR1(01), GR2(02) ! Push Multiple Registers On Stack
00001278 : 6500 : DSLL : GR1(00), GR2(00) ! Double Shift Left Logical
00001279 : 8120 : LR : GR1(02), GR2(00) ! Single Precision Integer Load
0000127A : 4A27003F : ANDM : GR(02), DATA(003F) ! Logical AND
0000127C : 8002164C : L : GR(00), RX(02), ADDR(164C) ! Single Precision Integer Load
0000127E : 6600 : DSRL : GR1(00), GR2(00) ! Double Shift Right Logical
0000127F : 4A07000F : ANDM : GR(00), DATA(000F) ! Logical AND
00001281 : 4820A00E : XIO : GR( 2), RX( 0), DATA(A00E) ! Execute Input/Output
00001283 : 4A27FFF0 : ANDM : GR(02), DATA(FFF0) ! Logical AND
00001285 : E120 : ORR : GR1(02), GR2(00) ! Inclusive Logical OR
00001286 : 4820200E : XIO : GR( 2), RX( 0), DATA(200E) ! Execute Input/Output
00001288 : 8101 : LR : GR1(00), GR2(01) ! Single Precision Integer Load
00001289 : 8F12 : POPM : GR1(01), GR2(02) ! Pop Multiple Registers Off the Stack
0000128A : 7FF0 : URS : GR1(0F), GR2(00) ! Unstack IC And Return From Subroutine