00000: nop
00001: nop
00002: delayed rom 12
00003: if n/c goto 00303
00004: delayed rom 2
00005: if n/c goto 00133
00006: c -> a[x]
00007: c -> addr
00010: data register -> c 0
00011: a exchange c[w]
00012: rotate a left
00013: rotate a left
00014: c - 1 -> c[xs]
00015: if n/c goto 00012
00016: return
00017: delayed rom 6
00020: if n/c goto 00006
00021: m2 exch c
00022: m2 -> c
00023: return
00024: 1 -> s 1
00025: m2 -> c
00026: if c[x] = 0 then goto 00034
00030: nop
00031: 0 -> s 3
00032: if 1 = s 3 then goto 00035
00034: jsb 00017
00035: delayed rom 2
00036: jsb 00167
00037: if n/c goto 00234
00040: if 1 = s 2 then goto 00053
00042: if 1 = s 1 then goto 00061
00044: 1 -> s 2
00045: 0 -> s 12
00046: m2 -> c
00047: if c[x] # 0 then goto 00052
00051: jsb 00017
00052: if n/c goto 00035
00053: 0 -> s 2
00054: jsb 00017
00055: 1 -> s 9
00056: jsb 00323
00057: 0 -> s 12
00060: if n/c goto 00115
00061: 1 -> s 9
00062: 0 -> s 12
00063: jsb 00323
00064: if n/c goto 00114
00065: 0 -> s 9
00066: if n/c goto 00073
00067: b exchange c[w]
00070: 1 -> s 9
00071: delayed rom 5
00072: jsb 00036
00073: b exchange c[w]
00074: if 0 = s 11 then goto 00101
00076: jsb 00315
00077: 0 -> s 2
00100: 0 -> s 1
00101: 0 -> s 12
00102: jsb 00323
00103: c -> a[w]
00104: c -> data register 15
00105: p <- 1
00106: load constant 1
00107: c -> addr
00110: b -> c[w]
00111: c -> data register 15
00112: a -> b[w]
00113: b -> c[w]
00114: jsb 00315
00115: binary
00116: delayed rom 2
00117: jsb 00167
00120: b -> c[w]
00121: if 1 = s 2 then goto 00223
00123: 0 -> s 1
00124: 0 -> s 11
00125: 0 -> c[s]
00126: m1 exch c
00127: b -> c[w]
00130: 0 -> s 3
00131: if 0 = s 3 then goto 00232
00133: if 0 = s 12 then goto 00140
00135: delayed rom 7
00136: jsb 00360
00137: if n/c goto 00142
00140: delayed rom 4
00141: jsb 00000
00142: delayed rom 2
00143: jsb 00371
00144: cpu woodstock
00145: display off
00146: display toggle
00147: 0 -> s 15
00150: if 1 = s 15 then goto 00147
00152: 0 -> s 1
00153: 0 -> s 3
00154: if 0 = s 3 then goto 00163
00156: if 0 = s 11 then goto 00165
00160: 0 -> s 11
00161: b exchange c[w]
00162: if n/c goto 00062
00163: if 0 = s 11 then goto 00232
00165: 0 -> s 5
00166: if 1 = s 5 then goto 00173
00170: jsb 00331
00171: jsb 00331
00172: nop
00173: if 0 = s 15 then goto 00152
00175: display off
00176: b exchange c[w]
00177: keys to a
00200: 0 -> s 13
00201: binary
00202: 0 -> c[x]
00203: c + 1 -> c[x]
00204: a - 1 -> a[xs]
00205: if n/c goto 00203
00206: c - 1 -> c[x]
00207: 0 -> a[xs]
00210: shift right a[x]
00211: a + c -> a[x]
00212: c + c -> c[x]
00213: c + c -> c[x]
00214: a + c -> a[x]
00215: shift left a[x]
00216: p <- 1
00217: m1 -> c
00220: 0 -> c[x]
00221: delayed rom 1
00222: a -> rom address
00223: if 1 = s 12 then goto 00306
00225: 0 -> s 15
00226: if 0 = s 15 then goto 00306
00230: 0 -> s 2
00231: if n/c goto 00056
00232: b exchange c[w]
00233: 1 -> s 11
00234: m2 -> c
00235: delayed rom 4
00236: jsb 00363
00237: m1 -> c
00240: a exchange c[ms]
00241: m1 exch c
00242: m2 -> c
00243: if c[x] # 0 then goto 00251
00245: m1 -> c
00246: a exchange c[ms]
00247: 0 -> c[w]
00250: if n/c goto 00254
00251: jsb 00006
00252: delayed rom 3
00253: jsb 00250
00254: p <- 11
00255: load constant 2
00256: b exchange c[w]
00257: display off
00260: display toggle
00261: 0 -> s 15
00262: if 1 = s 15 then goto 00261
00264: display off
00265: 0 -> s 3
00266: if 0 = s 3 then goto 00144
00270: b exchange c[w]
00271: m2 -> c
00272: jsb 00006
00273: if 1 = s 1 then goto 00311
00275: if 1 = s 2 then goto 00311
00277: if n/c goto 00055
00300: 0 -> s 11
00301: jsb 00017
00302: if 1 = s 11 then goto 01301
00304: delayed rom 11
00305: if n/c goto 00205
00306: m2 -> c
00307: jsb 00006
00310: display toggle
00311: a exchange c[w]
00312: m1 exch c
00313: delayed rom 12
00314: if n/c goto 00021
00315: if 1 = s 2 then goto 00321
00317: if 0 = s 1 then goto 00322
00321: if n/c goto 00017
00322: return
00323: p <- 1
00324: load constant 2
00325: c -> addr
00326: data register -> c 15
00327: b exchange c[w]
00330: return
00331: p <- 0
00332: if a[p] # 0 then goto 00361
00334: a - 1 -> a[p]
00335: jsb 00365
00336: c - 1 -> c[p]
00337: b exchange c[w]
00340: p <- 1
00341: load constant 2
00342: c -> addr
00343: data register -> c 15
00344: a exchange b[p]
00345: p - 1 -> p
00346: 0 -> s 15
00347: if 1 = s 15 then goto 00175
00351: if p # 4 then goto 00345
00353: p <- 0
00354: a + 1 -> a[p]
00355: if n/c goto 00345
00356: p <- 0
00357: a exchange b[p]
00360: return
00361: 0 -> a[p]
00362: jsb 00365
00363: c + 1 -> c[p]
00364: if n/c goto 00337
00365: p <- 13
00366: p - 1 -> p
00367: if b[p] = 0 then goto 00366
00371: b -> c[w]
00372: return
00373: nop
00374: nop
00375: nop
00376: nop
00377: nop
00400: delayed rom 2
00401: if n/c goto 00567
00402: if 0 = s 4 then goto 00407
00404: load constant 1
00405: load constant 10
00406: if n/c goto 00553
00407: if 0 = s 7 then goto 00404
00411: if 0 = s 6 then goto 00575
00413: jsb 00763
00414: 1 -> s 6
00415: p <- 0
00416: load constant 10
00417: if n/c goto 00616
00420: c + 1 -> c[x]
00421: c + 1 -> c[x]
00422: 1 -> s 13
00423: if n/c goto 00463
00424: if n/c goto 00701
00425: if n/c goto 00666
00426: if n/c goto 00714
00427: if n/c goto 00551
00430: if 0 = s 4 then goto 00651
00432: if 0 = s 6 then goto 01312
00434: if n/c goto 00655
00435: nop
00436: c + 1 -> c[x]
00437: c + 1 -> c[x]
00440: if n/c goto 00420
00441: if n/c goto 00453
00442: c + 1 -> c[x]
00443: c + 1 -> c[x]
00444: c + 1 -> c[x]
00445: if n/c goto 00732
00446: delayed rom 2
00447: if n/c goto 00410
00450: load constant 5
00451: load constant 12
00452: if n/c goto 00562
00453: delayed rom 2
00454: if n/c goto 00400
00455: if n/c goto 00542
00456: if n/c goto 00402
00457: if n/c goto 00733
00460: delayed rom 2
00461: if n/c goto 00414
00462: if n/c goto 00421
00463: c + 1 -> c[x]
00464: if n/c goto 00442
00465: delayed rom 2
00466: if n/c goto 00404
00467: if n/c goto 00645
00470: if n/c goto 00627
00471: if n/c goto 00611
00472: if n/c goto 00602
00473: if 1 = s 4 then goto 00477
00475: if 1 = s 7 then goto 00662
00477: jsb 00400
00500: if n/c goto 00647
00501: if n/c goto 00524
00502: if n/c goto 00516
00503: nop
00504: if n/c goto 00513
00505: if 0 = s 4 then goto 00535
00507: if 1 = s 6 then goto 00533
00511: load constant 4
00512: if n/c goto 00531
00513: if 1 = s 4 then goto 00114
00515: if n/c goto 00540
00516: if 0 = s 4 then goto 00537
00520: if 1 = s 6 then goto 01154
00522: load constant 6
00523: if n/c goto 00531
00524: if 0 = s 4 then goto 00536
00526: if 1 = s 6 then goto 00534
00530: load constant 5
00531: load constant 15
00532: if n/c goto 00562
00533: c + 1 -> c[x]
00534: c + 1 -> c[x]
00535: c + 1 -> c[x]
00536: c + 1 -> c[x]
00537: c + 1 -> c[x]
00540: c + 1 -> c[x]
00541: if n/c goto 00562
00542: if 0 = s 4 then goto 00562
00544: if 1 = s 6 then goto 00450
00546: load constant 6
00547: load constant 11
00550: if n/c goto 00562
00551: load constant 4
00552: load constant 10
00553: p <- 1
00554: if 0 = s 4 then goto 00562
00556: if 1 = s 6 then goto 00561
00560: c + 1 -> c[p]
00561: c + 1 -> c[p]
00562: jsb 00400
00563: if 1 = s 13 then goto 00124
00565: c -> a[w]
00566: m1 exch c
00567: jsb 00400
00570: 0 -> s 3
00571: if 0 = s 3 then goto 00300
00573: delayed rom 12
00574: if n/c goto 00421
00575: if 0 = s 8 then goto 00404
00577: jsb 00763
00600: 1 -> s 10
00601: if n/c goto 00616
00602: if 0 = s 4 then goto 00024
00604: if 0 = s 6 then goto 01301
00606: load constant 4
00607: jsb 00400
00610: if n/c goto 00673
00611: if 1 = s 4 then goto 00620
00613: load constant 7
00614: jsb 00400
00615: 1 -> s 7
00616: 1 -> s 13
00617: if n/c goto 00563
00620: if 1 = s 6 then goto 00625
00622: load constant 6
00623: load constant 14
00624: if n/c goto 00562
00625: load constant 5
00626: if n/c goto 00607
00627: if 1 = s 4 then goto 00635
00631: load constant 8
00632: jsb 00400
00633: 1 -> s 8
00634: if n/c goto 00615
00635: if 1 = s 6 then goto 00643
00637: load constant 15
00640: jsb 00400
00641: 1 -> s 10
00642: if n/c goto 00616
00643: load constant 6
00644: if n/c goto 00607
00645: jsb 00400
00646: 1 -> s 6
00647: 1 -> s 4
00650: if n/c goto 00616
00651: if 0 = s 6 then goto 00655
00653: if 1 = s 10 then goto 00660
00655: load constant 4
00656: load constant 14
00657: if n/c goto 00553
00660: load constant 0
00661: if n/c goto 00531
00662: jsb 00400
00663: 1 -> s 7
00664: m1 exch c
00665: if n/c goto 00647
00666: if 1 = s 4 then goto 00675
00670: load constant 10
00671: jsb 00400
00672: 1 -> s 7
00673: 1 -> s 6
00674: if n/c goto 00616
00675: if 1 = s 6 then goto 00670
00677: load constant 6
00700: if n/c goto 00451
00701: if 0 = s 4 then goto 00710
00703: if 1 = s 6 then goto 00710
00705: load constant 6
00706: load constant 13
00707: if n/c goto 00562
00710: load constant 9
00711: jsb 00400
00712: 1 -> s 10
00713: if n/c goto 00672
00714: if 1 = s 7 then goto 00724
00716: if 0 = s 4 then goto 00727
00720: if 1 = s 6 then goto 00727
00722: load constant 9
00723: m1 exch c
00724: m1 exch c
00725: shift right c[x]
00726: if n/c goto 00562
00727: load constant 4
00730: load constant 11
00731: if n/c goto 00553
00732: c + 1 -> c[x]
00733: if 1 = s 4 then goto 00745
00735: if 1 = s 7 then goto 00747
00737: if 1 = s 6 then goto 00756
00741: if 1 = s 8 then goto 01045
00743: if 1 = s 10 then goto 00747
00745: c + 1 -> c[p]
00746: if n/c goto 00553
00747: a exchange c[wp]
00750: m1 exch c
00751: a + c -> c[wp]
00752: m1 exch c
00753: a exchange c[wp]
00754: m1 -> c
00755: if n/c goto 00562
00756: if 0 = s 8 then goto 00747
00760: if 1 = s 13 then goto 00745
00762: if n/c goto 00747
00763: m1 exch c
00764: 0 -> s 7
00765: 1 -> s 8
00766: 0 -> s 10
00767: return
00770: c + 1 -> c[p]
00771: c + 1 -> c[p]
00772: c + 1 -> c[p]
00773: c + 1 -> c[p]
00774: 1 -> s 8
00775: if n/c goto 00616
00776: nop
00777: nop
01000: jsb 01025
01001: if p = 1 then goto 00773
01003: if n/c goto 01022
01004: jsb 01025
01005: if p = 1 then goto 00772
01007: if n/c goto 01021
01010: jsb 01025
01011: if p = 1 then goto 00771
01013: if n/c goto 01020
01014: jsb 01025
01015: if p = 1 then goto 00770
01017: c + 1 -> c[p]
01020: c + 1 -> c[p]
01021: c + 1 -> c[p]
01022: c + 1 -> c[p]
01023: delayed rom 1
01024: if n/c goto 01153
01025: if 0 = s 4 then goto 01033
01027: load constant 1
01030: load constant 10
01031: p <- 0
01032: return
01033: if 0 = s 6 then goto 01027
01035: if 0 = s 7 then goto 01027
01037: if 1 = s 10 then goto 01027
01041: if 1 = s 8 then goto 01027
01043: m1 exch c
01044: return
01045: a exchange c[x]
01046: m1 exch c
01047: p <- 0
01050: a exchange c[p]
01051: if c[xs] # 0 then goto 01306
01053: a exchange c[x]
01054: shift left a[x]
01055: a exchange c[x]
01056: delayed rom 1
01057: if n/c goto 01216
01060: b exchange c[w]
01061: binary
01062: 0 -> c[w]
01063: p <- 13
01064: load constant 2
01065: load constant 9
01066: b exchange c[w]
01067: p <- 0
01070: if n/c goto 01073
01071: shift right b[m]
01072: a - 1 -> a[p]
01073: if a[p] # 0 then goto 01071
01075: p <- 1
01076: a + 1 -> a[p]
01077: if n/c goto 01116
01100: p <- 12
01101: if b[p] = 0 then goto 01110
01103: a + 1 -> a[p]
01104: if n/c goto 01106
01105: return
01106: a - 1 -> a[p]
01107: return
01110: a + 1 -> a[p]
01111: if n/c goto 01113
01112: a + 1 -> a[p]
01113: a - 1 -> a[p]
01114: p - 1 -> p
01115: if n/c goto 01101
01116: a - 1 -> a[p]
01117: p <- 4
01120: shift left a[wp]
01121: b exchange c[w]
01122: load constant 2
01123: b exchange c[w]
01124: if n/c goto 01100
01125: delayed rom 0
01126: if n/c goto 01061
01127: 0 -> c[w]
01130: m2 exch c
01131: m2 -> c
01132: return
01133: p <- 1
01134: load constant 1
01135: load constant 14
01136: p <- 1
01137: jsb 01141
01140: if n/c goto 01125
01141: a exchange c[w]
01142: binary
01143: 0 -> c[w]
01144: a - 1 -> a[wp]
01145: a exchange c[w]
01146: c -> addr
01147: a exchange c[w]
01150: c -> data
01151: a - 1 -> a[wp]
01152: if n/c goto 01145
01153: return
01154: 0 -> s 3
01155: if 1 = s 3 then goto 00114
01157: 0 -> c[w]
01160: p <- 1
01161: load constant 2
01162: load constant 14
01163: p <- 0
01164: jsb 01372
01165: jsb 01127
01166: if n/c goto 01125
01167: 0 -> s 4
01170: 0 -> s 0
01171: 0 -> s 14
01172: 0 -> s 6
01173: 0 -> s 7
01174: 0 -> s 8
01175: 0 -> s 10
01176: 0 -> s 13
01177: return
01200: p <- 2
01201: load constant 6
01202: load constant 2
01203: load constant 13
01204: c -> a[w]
01205: m2 -> c
01206: if c[x] # 0 then goto 01213
01210: p <- 1
01211: load constant 2
01212: if n/c goto 01226
01213: c + 1 -> c[xs]
01214: if a >= c[xs] then goto 01226
01216: 0 -> c[xs]
01217: p <- 0
01220: c + 1 -> c[p]
01221: if a >= c[p] then goto 01226
01223: 0 -> c[w]
01224: if 1 = s 11 then goto 01210
01226: m2 exch c
01227: m2 -> c
01230: return
01231: 0 -> a[w]
01232: 0 -> c[w]
01233: 0 -> s 1
01234: 0 -> s 2
01235: p <- 13
01236: load constant 14
01237: load constant 10
01240: load constant 10
01241: load constant 12
01242: load constant 10
01243: binary
01244: c - 1 -> c[wp]
01245: a exchange c[w]
01246: b exchange c[w]
01247: display off
01250: display toggle
01251: p <- 2
01252: load constant 4
01253: c - 1 -> c[x]
01254: if n/c goto 01253
01255: display toggle
01256: c - 1 -> c[wp]
01257: if n/c goto 01256
01260: display toggle
01261: 0 -> s 15
01262: if 1 = s 15 then goto 01261
01264: 0 -> s 3
01265: if 1 = s 3 then goto 01271
01267: if 0 = s 15 then goto 01264
01271: if 1 = s 15 then goto 01276
01273: 0 -> s 3
01274: if 1 = s 3 then goto 01271
01276: display toggle
01277: delayed rom 0
01300: if n/c goto 01062
01301: 1 -> s 11
01302: jsb 01200
01303: 1 -> s 11
01304: delayed rom 0
01305: if n/c goto 01035
01306: 0 -> c[xs]
01307: 0 -> s 8
01310: delayed rom 4
01311: if n/c goto 01326
01312: 0 -> s 3
01313: if 1 = s 3 then goto 00114
01315: delayed rom 11
01316: if n/c goto 01262
01317: nop
01320: nop
01321: nop
01322: nop
01323: nop
01324: nop
01325: nop
01326: nop
01327: nop
01330: nop
01331: nop
01332: nop
01333: nop
01334: nop
01335: nop
01336: nop
01337: nop
01340: nop
01341: nop
01342: nop
01343: nop
01344: nop
01345: nop
01346: nop
01347: nop
01350: nop
01351: nop
01352: nop
01353: nop
01354: nop
01355: nop
01356: nop
01357: nop
01360: nop
01361: nop
01362: nop
01363: nop
01364: nop
01365: nop
01366: nop
01367: nop
01370: if n/c goto 01125
01371: if n/c goto 01060
01372: if n/c goto 01141
01373: if n/c goto 01302
01374: if n/c goto 01231
01375: nop
01376: nop
01377: nop
01400: nop
01401: nop
01402: nop
01403: nop
01404: nop
01405: nop
01406: nop
01407: nop
01410: nop
01411: nop
01412: if n/c goto 01702
01413: c - 1 -> c[p]
01414: c - 1 -> c[p]
01415: c - 1 -> c[p]
01416: if n/c goto 01563
01417: nop
01420: if n/c goto 01546
01421: c + 1 -> c[m]
01422: c + 1 -> c[m]
01423: c + 1 -> c[m]
01424: if n/c goto 01637
01425: c - 1 -> c[xs]
01426: if n/c goto 01646
01427: if n/c goto 01627
01430: if n/c goto 01626
01431: if n/c goto 01520
01432: if n/c goto 01523
01433: if n/c goto 01541
01434: if n/c goto 01470
01435: if n/c goto 01472
01436: if n/c goto 01464
01437: if n/c goto 01452
01440: if n/c goto 01631
01441: c - 1 -> c[w]
01442: c - 1 -> c[w]
01443: if n/c goto 01634
01444: c - 1 -> c[w]
01445: c - 1 -> c[w]
01446: if n/c goto 01635
01447: c - 1 -> c[w]
01450: c - 1 -> c[w]
01451: if n/c goto 01563
01452: c - 1 -> c[p]
01453: if c[s] = 0 then goto 01462
01455: c - 1 -> c[p]
01456: p <- 3
01457: load constant 7
01460: load constant 1
01461: p <- 6
01462: a - 1 -> a[w]
01463: if n/c goto 01507
01464: jsb 01713
01465: if c[s] = 0 then goto 01615
01467: if n/c goto 01500
01470: c + 1 -> c[xs]
01471: a + 1 -> a[p]
01472: if c[s] # 0 then goto 01477
01474: c + 1 -> c[w]
01475: c + 1 -> c[w]
01476: if n/c goto 01503
01477: a + 1 -> a[p]
01500: a + 1 -> a[p]
01501: load constant 7
01502: c - 1 -> c[w]
01503: p <- 1
01504: a exchange c[p]
01505: 0 - c - 1 -> c[p]
01506: a exchange c[p]
01507: shift left a[w]
01510: a -> rom address
01511: nop
01512: c - 1 -> c[w]
01513: if n/c goto 01563
01514: c + 1 -> c[w]
01515: if n/c goto 01537
01516: if n/c goto 01701
01517: if n/c goto 01514
01520: if c[s] = 0 then goto 01612
01522: c + 1 -> c[xs]
01523: if c[s] = 0 then goto 01611
01525: if n/c goto 01544
01526: p <- 3
01527: load constant 1
01530: load constant 4
01531: return
01532: c - 1 -> c[w]
01533: if n/c goto 01563
01534: load constant 7
01535: if n/c goto 01702
01536: if n/c goto 01701
01537: c + 1 -> c[w]
01540: if n/c goto 01557
01541: if c[s] = 0 then goto 01610
01543: jsb 01713
01544: load constant 2
01545: if n/c goto 01503
01546: p <- 6
01547: load constant 1
01550: load constant 5
01551: if n/c goto 01627
01552: if n/c goto 01512
01553: if n/c goto 01534
01554: if n/c goto 01703
01555: if n/c goto 01702
01556: if n/c goto 01415
01557: c + 1 -> c[p]
01560: p <- 3
01561: load constant 1
01562: load constant 5
01563: 0 -> c[s]
01564: if c[s] = 0 then goto 01571
01566: jsb 01571
01567: load constant 3
01570: return
01571: a exchange c[w]
01572: shift left a[w]
01573: shift right a[x]
01574: a - 1 -> a[xs]
01575: shift left a[w]
01576: shift left a[w]
01577: p <- 0
01600: a - 1 -> a[p]
01601: m1 -> c
01602: p <- 11
01603: a exchange c[wp]
01604: a exchange c[w]
01605: 0 -> c[w]
01606: p <- 3
01607: return
01610: c - 1 -> c[xs]
01611: c - 1 -> c[xs]
01612: c - 1 -> c[xs]
01613: p <- 6
01614: jsb 01527
01615: p <- 1
01616: load constant 0
01617: load constant 10
01620: p <- 0
01621: if c[s] = 0 then goto 01624
01623: a - c -> a[p]
01624: a exchange c[p]
01625: if n/c goto 01564
01626: c - 1 -> c[xs]
01627: c - 1 -> c[xs]
01630: if n/c goto 01615
01631: load constant 7
01632: load constant 2
01633: if n/c goto 01563
01634: c + 1 -> c[p]
01635: c + 1 -> c[p]
01636: if n/c goto 01563
01637: c + 1 -> c[m]
01640: c + 1 -> c[m]
01641: p <- 6
01642: load constant 2
01643: load constant 3
01644: p <- 2
01645: load constant 1
01646: c + 1 -> c[m]
01647: if n/c goto 01615
01650: 0 -> c[w]
01651: c - 1 -> c[w]
01652: p <- 0
01653: load constant 10
01654: jsb 01526
01655: load constant 4
01656: if a >= c[p] then goto 01661
01660: 0 -> c[s]
01661: load constant 2
01662: p <- 1
01663: 0 -> a[xs]
01664: a + 1 -> a[xs]
01665: a exchange c[p]
01666: 0 - c - 1 -> c[p]
01667: a exchange c[p]
01670: a -> rom address
01671: load constant 7
01672: jsb 01713
01673: if n/c goto 01702
01674: c - 1 -> c[xs]
01675: if n/c goto 01415
01676: p <- 3
01677: load constant 2
01700: load constant 4
01701: c + 1 -> c[w]
01702: c + 1 -> c[w]
01703: c + 1 -> c[w]
01704: if n/c goto 01563
01705: c + 1 -> c[m]
01706: if n/c goto 01415
01707: p <- 3
01710: load constant 2
01711: load constant 3
01712: if n/c goto 01563
01713: p <- 3
01714: load constant 15
01715: load constant 15
01716: return
01717: nop
01720: nop
01721: nop
01722: nop
01723: nop
01724: nop
01725: nop
01726: nop
01727: nop
01730: nop
01731: nop
01732: nop
01733: nop
01734: nop
01735: nop
01736: nop
01737: nop
01740: nop
01741: nop
01742: nop
01743: nop
01744: nop
01745: nop
01746: nop
01747: nop
01750: nop
01751: nop
01752: nop
01753: nop
01754: nop
01755: nop
01756: nop
01757: if n/c goto 01671
01760: c - 1 -> c[w]
01761: c - 1 -> c[w]
01762: c - 1 -> c[w]
01763: if n/c goto 01672
01764: c - 1 -> c[w]
01765: if n/c goto 01702
01766: c - 1 -> c[xs]
01767: if n/c goto 01674
01770: if n/c goto 01705
01771: if n/c goto 01707
01772: c - 1 -> c[m]
01773: c - 1 -> c[m]
01774: c - 1 -> c[m]
01775: if n/c goto 01710
01776: if n/c goto 01676
01777: nop
02000: jsb 02235
02001: a exchange c[w]
02002: jsb 02205
02003: shift right a[x]
02004: shift right a[x]
02005: f exch a
02006: a -> b[s]
02007: decimal
02010: a - 1 -> a[s]
02011: if n/c goto 02042
02012: c -> a[w]
02013: if a[xs] # 0 then goto 00031
02015: p <- 1
02016: load constant 1
02017: load constant 0
02020: if a >= c[x] then goto 00037
02022: b exchange c[x]
02023: 0 -> a[x]
02024: f -> a
02025: a + c -> a[x]
02026: if a >= b[x] then goto 00045
02030: if n/c goto 02047
02031: 0 -> a[x]
02032: f -> a
02033: a + 1 -> a[x]
02034: a + c -> a[x]
02035: if n/c goto 02037
02036: if n/c goto 02047
02037: 0 -> c[s]
02040: c + 1 -> c[s]
02041: b exchange c[s]
02042: 0 -> a[x]
02043: f -> a
02044: if n/c goto 02047
02045: a exchange b[x]
02046: a - 1 -> a[x]
02047: data register -> c 14
02050: jsb 02213
02051: if b[s] = 0 then goto 00177
02053: p - 1 -> p
02054: jsb 02221
02055: if c[s] = 0 then goto 00071
02057: if b[s] = 0 then goto 00202
02061: c + 1 -> c[x]
02062: if c[xs] = 0 then goto 00070
02064: c - 1 -> c[xs]
02065: if c[xs] = 0 then goto 00173
02067: c + 1 -> c[xs]
02070: shift right c[ms]
02071: jsb 02227
02072: if b[s] = 0 then goto 00150
02074: a exchange b[s]
02075: a - 1 -> a[s]
02076: if a[s] # 0 then goto 00103
02100: if a[xs] # 0 then goto 00130
02102: if n/c goto 02133
02103: 0 -> a[s]
02104: b exchange c[x]
02105: 0 -> c[x]
02106: p <- 2
02107: load constant 1
02110: c - 1 -> c[x]
02111: a + c -> a[x]
02112: 0 -> c[x]
02113: load constant 3
02114: a - c -> a[x]
02115: if n/c goto 02114
02116: a + c -> a[x]
02117: shift right c[x]
02120: a - c -> a[x]
02121: if n/c goto 02120
02122: a + c -> a[x]
02123: b -> c[x]
02124: a - 1 -> a[x]
02125: if n/c goto 02136
02126: if c[xs] = 0 then goto 00132
02130: 0 - c -> c[x]
02131: c - 1 -> c[xs]
02132: c -> a[x]
02133: p <- 3
02134: shift left a[wp]
02135: if n/c goto 02162
02136: c - 1 -> c[x]
02137: a + 1 -> a[s]
02140: if n/c goto 02124
02141: if c[ms] = 0 then goto 00037
02143: shift right a[w]
02144: c + 1 -> c[x]
02145: if c[x] # 0 then goto 00143
02147: if n/c goto 02157
02150: if a[xs] # 0 then goto 00141
02152: if n/c goto 02155
02153: a + 1 -> a[s]
02154: a - 1 -> a[x]
02155: if a[x] # 0 then goto 00153
02157: binary
02160: 0 -> a[x]
02161: a - 1 -> a[x]
02162: rotate a left
02163: f exch a
02164: shift right a[w]
02165: f -> a
02166: data register -> c 14
02167: c -> a[s]
02170: b exchange c[w]
02171: b -> c[w]
02172: return
02173: data register -> c 14
02174: c -> a[w]
02175: 0 -> a[s]
02176: if n/c goto 02133
02177: if c[xs] # 0 then goto 00054
02201: if n/c goto 02053
02202: c + 1 -> c[x]
02203: p - 1 -> p
02204: if n/c goto 02070
02205: p <- 1
02206: load constant 1
02207: c -> addr
02210: b -> c[w]
02211: c -> data register 14
02212: return
02213: 0 -> c[s]
02214: p <- 13
02215: p - 1 -> p
02216: a - 1 -> a[x]
02217: if n/c goto 02215
02220: return
02221: 0 -> a[w]
02222: c -> a[wp]
02223: a + c -> a[ms]
02224: 0 -> a[wp]
02225: a exchange c[ms]
02226: return
02227: c -> a[ms]
02230: binary
02231: a - 1 -> a[wp]
02232: c -> a[x]
02233: decimal
02234: return
02235: p <- 1
02236: load constant 2
02237: c -> addr
02240: data register -> c 14
02241: return
02242: 0 -> s 14
02243: m1 exch c
02244: jsb 02235
02245: if c[p] = 0 then goto 00255
02247: c - 1 -> c[x]
02250: if c[p] = 0 then goto 00254
02252: 1 -> s 14
02253: if n/c goto 02255
02254: 1 -> s 0
02255: m1 -> c
02256: p <- 12
02257: return
02260: b exchange c[w]
02261: delayed rom 5
02262: jsb 02065
02263: data register -> c 10
02264: b exchange c[w]
02265: if b[m] = 0 then goto 01034
02267: data register -> c 13
02270: a exchange c[w]
02271: data register -> c 10
02272: delayed rom 5
02273: jsb 02015
02274: if 1 = s 13 then goto 01032
02276: 1 -> s 13
02277: stack -> a
02300: c -> stack
02301: data register -> c 11
02302: if n/c goto 02270
02303: c + 1 -> c[x]
02304: if c[xs] = 0 then goto 00311
02306: 0 -> c[x]
02307: p <- 0
02310: load constant 2
02311: c - 1 -> c[x]
02312: return
02313: jsb 02303
02314: if a[x] # 0 then goto 00317
02316: a + 1 -> a[x]
02317: a - 1 -> a[x]
02320: a - c -> a[x]
02321: if n/c goto 02324
02322: a - 1 -> a[x]
02323: a - 1 -> a[x]
02324: a + 1 -> a[x]
02325: a exchange c[x]
02326: decimal
02327: if c[x] = 0 then goto 00360
02331: 0 -> c[xs]
02332: 0 -> c[ms]
02333: jsb 02303
02334: c + 1 -> c[x]
02335: 0 - c - 1 -> c[x]
02336: a exchange c[x]
02337: 0 -> a[ms]
02340: shift left a[x]
02341: shift left a[w]
02342: shift left a[w]
02343: p <- 3
02344: load constant 7
02345: if n/c goto 02350
02346: binary
02347: a + 1 -> a[x]
02350: decimal
02351: a - c -> a[ms]
02352: if n/c goto 02346
02353: a + c -> a[ms]
02354: shift left a[x]
02355: a exchange c[w]
02356: load constant 2
02357: shift right c[w]
02360: c -> a[w]
02361: delayed rom 12
02362: if n/c goto 02171
02363: decimal
02364: 0 -> c[ms]
02365: 0 -> a[w]
02366: if c[x] = 0 then goto 00411
02370: p <- 13
02371: load constant 1
02372: load constant 0
02373: load constant 6
02374: a exchange c[ms]
02375: p <- 11
02376: load constant 7
02377: p <- 0
02400: a - c -> a[ms]
02401: c - 1 -> c[p]
02402: if n/c goto 02400
02403: p <- 11
02404: load constant 1
02405: a - c -> a[ms]
02406: c - 1 -> c[xs]
02407: if n/c goto 02405
02410: shift left a[ms]
02411: p <- 11
02412: binary
02413: a - 1 -> a[wp]
02414: return
02415: if c[m] = 0 then goto 01034
02417: delayed rom 6
02420: if n/c goto 02522
02421: delayed rom 6
02422: if n/c goto 02663
02423: a exchange c[w]
02424: if 0 = s 13 then goto 00427
02426: 0 - c - 1 -> c[s]
02427: delayed rom 6
02430: if n/c goto 02573
02431: jsb 02436
02432: c -> data
02433: return
02434: delayed rom 6
02435: if n/c goto 02437
02436: if c[m] # 0 then goto 00441
02440: 0 -> c[w]
02441: if c[xs] = 0 then goto 00451
02443: decimal
02444: c - 1 -> c[x]
02445: c + 1 -> c[xs]
02446: c - 1 -> c[xs]
02447: if n/c goto 02452
02450: c + 1 -> c[x]
02451: return
02452: p <- 12
02453: c + c -> c[xs]
02454: if n/c goto 02457
02455: 0 -> c[w]
02456: if n/c goto 02463
02457: 0 -> c[wp]
02460: c - 1 -> c[wp]
02461: 0 -> c[xs]
02462: 1 -> s 11
02463: p <- 13
02464: return
02465: p <- 1
02466: load constant 0
02467: c -> addr
02470: return
02471: 1 -> s 13
02472: m1 exch c
02473: jsb 02465
02474: data register -> c 11
02475: a exchange c[w]
02476: m1 -> c
02477: jsb 02424
02500: jsb 02431
02501: m1 -> c
02502: c -> a[w]
02503: jsb 02434
02504: a exchange c[w]
02505: data register -> c 12
02506: jsb 02423
02507: jsb 02431
02510: data register -> c 13
02511: d -> a
02512: jsb 02423
02513: jsb 02431
02514: d -> a
02515: a exchange c[w]
02516: c -> a[w]
02517: jsb 02434
02520: a exchange c[w]
02521: data register -> c 14
02522: jsb 02423
02523: jsb 02431
02524: d -> a
02525: m1 -> c
02526: jsb 02434
02527: a exchange c[w]
02530: data register -> c 15
02531: jsb 02423
02532: jsb 02431
02533: 0 -> c[w]
02534: p <- 12
02535: c + 1 -> c[p]
02536: a exchange c[w]
02537: data register -> c 10
02540: jsb 02423
02541: jsb 02431
02542: 0 -> s 11
02543: delayed rom 0
02544: if n/c goto 02465
02545: m1 exch c
02546: jsb 02465
02547: 0 -> c[w]
02550: p <- 12
02551: c + 1 -> c[p]
02552: a exchange c[w]
02553: data register -> c 10
02554: jsb 02426
02555: b exchange c[w]
02556: b -> c[w]
02557: m1 exch c
02560: if b[m] = 0 then goto 01034
02562: if b[s] = 0 then goto 01034
02564: data register -> c 13
02565: c -> a[w]
02566: jsb 02434
02567: data register -> c 10
02570: jsb 02415
02571: data register -> c 12
02572: if 1 = s 13 then goto 00575
02574: data register -> c 14
02575: jsb 02426
02576: m1 -> c
02577: jsb 02415
02600: 0 -> c[s]
02601: jsb 02421
02602: if 1 = s 13 then goto 01032
02604: 1 -> s 13
02605: jsb 02436
02606: stack -> a
02607: c -> stack
02610: data register -> c 11
02611: if n/c goto 02565
02612: 0 -> c[w]
02613: p <- 12
02614: c + 1 -> c[p]
02615: a exchange c[w]
02616: jsb 02423
02617: jsb 02431
02620: if c[xs] = 0 then goto 00623
02622: 0 -> c[w]
02623: delayed rom 13
02624: if n/c goto 02546
02625: jsb 02741
02626: p <- 4
02627: if c[p] # 0 then goto 00632
02631: jsb 02712
02632: 0 -> b[w]
02633: 0 -> c[w]
02634: 0 -> s 2
02635: p <- 13
02636: load constant 14
02637: load constant 10
02640: load constant 10
02641: load constant 12
02642: load constant 10
02643: binary
02644: c - 1 -> c[wp]
02645: a exchange c[w]
02646: display off
02647: display toggle
02650: p <- 2
02651: load constant 4
02652: c - 1 -> c[x]
02653: if n/c goto 02652
02654: display toggle
02655: a exchange b[w]
02656: a - 1 -> a[p]
02657: jsb 02734
02660: a - 1 -> a[p]
02661: if n/c goto 02657
02662: a exchange b[w]
02663: display toggle
02664: 1 -> s 0
02665: 0 -> s 3
02666: if 1 = s 3 then goto 00674
02670: 0 -> s 0
02671: ???1320
02672: if 0 = s 3 then goto 00664
02674: 0 -> s 0
02675: nop
02676: 0 -> s 3
02677: ???1320
02700: if 1 = s 3 then goto 00706
02702: 1 -> s 0
02703: nop
02704: if 1 = s 3 then goto 00674
02706: display toggle
02707: jsb 02734
02710: delayed rom 0
02711: if n/c goto 02462
02712: 0 -> c[w]
02713: binary
02714: p <- 11
02715: c - 1 -> c[w]
02716: load constant 14
02717: load constant 15
02720: load constant 11
02721: load constant 14
02722: load constant 15
02723: load constant 8
02724: load constant 5
02725: load constant 1
02726: load constant 4
02727: load constant 3
02730: load constant 1
02731: load constant 4
02732: delayed rom 3
02733: if n/c goto 02402
02734: 0 -> c[w]
02735: c - 1 -> c[w]
02736: c -> addr
02737: data register -> c 15
02740: return
02741: delayed rom 4
02742: jsb 02635
02743: 0 -> s 0
02744: 0 -> a[w]
02745: 0 -> s 15
02746: if 1 = s 15 then goto 00745
02750: 1 -> s 0
02751: p <- 4
02752: if 0 = s 15 then goto 00751
02754: keys to a
02755: shift left a[x]
02756: a exchange c[wp]
02757: c + c -> c[xs]
02760: c + c -> c[xs]
02761: if n/c goto 02764
02762: load constant 1
02763: if n/c goto 02771
02764: p <- 3
02765: load constant 1
02766: c + c -> c[xs]
02767: if n/c goto 02771
02770: c - 1 -> c[m]
02771: a exchange c[x]
02772: c -> data register 14
02773: delayed rom 4
02774: jsb 02635
02775: p <- 3
02776: 0 -> s 0
02777: return
03000: 0 -> a[w]
03001: p <- 12
03002: a + 1 -> a[p]
03003: if c[m] = 0 then goto 01034
03005: if n/c goto 03122
03006: m2 -> c
03007: c - 1 -> c[xs]
03010: if n/c goto 03024
03011: p <- 2
03012: load constant 6
03013: p <- 0
03014: c - 1 -> c[p]
03015: if n/c goto 03024
03016: p <- 1
03017: if c[p] = 0 then goto 01022
03021: 1 -> s 11
03022: load constant 2
03023: load constant 13
03024: delayed rom 0
03025: if n/c goto 03021
03026: d -> a
03027: a - 1 -> a[x]
03030: a - 1 -> a[x]
03031: jsb 03037
03032: delayed rom 0
03033: if n/c goto 03070
03034: delayed rom 2
03035: if n/c goto 03374
03036: stack -> a
03037: 0 -> b[w]
03040: a exchange b[m]
03041: jsb 03055
03042: jsb 03112
03043: p <- 12
03044: 0 -> b[w]
03045: a -> b[x]
03046: a + b -> a[wp]
03047: if n/c goto 03052
03050: c + 1 -> c[x]
03051: a + 1 -> a[p]
03052: a exchange c[m]
03053: c -> a[w]
03054: return
03055: a + c -> c[x]
03056: p <- 3
03057: a - c -> c[s]
03060: if n/c goto 03062
03061: 0 - c -> c[s]
03062: 0 -> a[w]
03063: if n/c goto 03067
03064: p <- 0
03065: if n/c goto 03062
03066: a + b -> a[w]
03067: c - 1 -> c[p]
03070: if n/c goto 03066
03071: if p = 12 then goto 01100
03073: p + 1 -> p
03074: shift right a[w]
03075: if n/c goto 03067
03076: c + 1 -> c[x]
03077: shift right a[w]
03100: return
03101: a exchange b[w]
03102: jsb 03064
03103: m1 -> c
03104: if n/c goto 03112
03105: m1 exch c
03106: b -> c[w]
03107: jsb 03064
03110: m1 -> c
03111: c + c -> c[x]
03112: if a[s] # 0 then goto 01076
03114: return
03115: c -> a[w]
03116: if n/c goto 03037
03117: if c[m] = 0 then goto 01034
03121: stack -> a
03122: jsb 03124
03123: if n/c goto 03043
03124: 0 -> b[w]
03125: b exchange c[m]
03126: a - c -> c[s]
03127: if n/c goto 03131
03130: 0 - c -> c[s]
03131: a - c -> c[x]
03132: 0 -> a[x]
03133: 0 -> a[s]
03134: 0 -> c[m]
03135: p <- 12
03136: if n/c goto 03140
03137: c + 1 -> c[p]
03140: a - b -> a[w]
03141: if n/c goto 03137
03142: a + b -> a[w]
03143: p - 1 -> p
03144: if p # 2 then goto 01155
03146: a + 1 -> a[ms]
03147: b exchange c[x]
03150: 0 -> c[x]
03151: if n/c goto 03153
03152: a - 1 -> a[ms]
03153: if a >= b[w] then goto 01152
03155: shift left a[w]
03156: if p # 13 then goto 01140
03160: 0 -> a[w]
03161: a exchange c[w]
03162: a exchange c[s]
03163: b exchange c[x]
03164: if n/c goto 03237
03165: 0 -> a[w]
03166: a + 1 -> a[s]
03167: 0 - c -> c[x]
03170: shift right a[w]
03171: if n/c goto 03134
03172: stack -> a
03173: jsb 03175
03174: if n/c goto 03043
03175: p <- 12
03176: 0 -> b[w]
03177: a + 1 -> a[xs]
03200: a + 1 -> a[xs]
03201: c + 1 -> c[xs]
03202: c + 1 -> c[xs]
03203: if a >= c[x] then goto 01206
03205: a exchange c[w]
03206: a exchange c[m]
03207: if c[m] = 0 then goto 01212
03211: a exchange c[w]
03212: b exchange c[m]
03213: if a >= c[x] then goto 01222
03215: shift right b[w]
03216: a + 1 -> a[x]
03217: if b[w] = 0 then goto 01222
03221: if n/c goto 03213
03222: c - 1 -> c[xs]
03223: c - 1 -> c[xs]
03224: 0 -> a[x]
03225: a - c -> a[s]
03226: if a[s] # 0 then goto 01232
03230: a + b -> a[w]
03231: if n/c goto 03112
03232: if a >= b[m] then goto 01236
03234: 0 - c - 1 -> c[s]
03235: a exchange b[w]
03236: a - b -> a[w]
03237: p <- 12
03240: if a[wp] # 0 then goto 01250
03242: 0 -> c[x]
03243: return
03244: binary
03245: a + 1 -> a[s]
03246: decimal
03247: c - 1 -> c[x]
03250: if a[p] # 0 then goto 01243
03252: shift left a[wp]
03253: if n/c goto 03244
03254: if 0 = s 4 then goto 01257
03256: 0 - c - 1 -> c[s]
03257: jsb 03237
03260: if n/c goto 03043
03261: if c[s] # 0 then goto 01034
03263: 0 -> a[w]
03264: a exchange c[m]
03265: jsb 03267
03266: if n/c goto 03257
03267: a -> b[w]
03270: b exchange c[w]
03271: c + c -> c[w]
03272: c + c -> c[w]
03273: a + c -> c[w]
03274: b exchange c[w]
03275: 0 -> c[ms]
03276: c -> a[w]
03277: c + c -> c[x]
03300: if n/c goto 03302
03301: c - 1 -> c[m]
03302: c + c -> c[x]
03303: a + c -> c[x]
03304: p <- 0
03305: if c[p] # 0 then goto 01310
03307: shift right b[w]
03310: shift right c[w]
03311: a exchange c[x]
03312: 0 -> c[w]
03313: a exchange b[w]
03314: p <- 13
03315: load constant 5
03316: shift right c[w]
03317: if n/c goto 03326
03320: c + 1 -> c[p]
03321: a - c -> a[w]
03322: if n/c goto 03320
03323: a + c -> a[w]
03324: shift left a[w]
03325: p - 1 -> p
03326: shift right c[wp]
03327: if p # 0 then goto 01321
03331: 0 -> c[p]
03332: a exchange c[w]
03333: b exchange c[w]
03334: return
03335: 0 -> c[w]
03336: c -> addr
03337: data register -> c 13
03340: stack -> a
03341: c -> stack
03342: data register -> c 11
03343: if n/c goto 03032
03344: b exchange c[w]
03345: jsb 03373
03346: if n/c goto 03032
03347: p <- 0
03350: a exchange c[p]
03351: if c[xs] # 0 then goto 01360
03353: a exchange c[x]
03354: shift left a[x]
03355: a exchange c[x]
03356: delayed rom 1
03357: if n/c goto 03216
03360: 0 -> c[xs]
03361: 0 -> s 8
03362: delayed rom 4
03363: if n/c goto 03326
03364: nop
03365: nop
03366: a + c -> a[wp]
03367: shift right c[wp]
03370: if c[wp] # 0 then goto 01366
03372: return
03373: if b[m] = 0 then goto 01406
03375: p <- 12
03376: b -> c[x]
03377: c + 1 -> c[x]
03400: c + 1 -> c[x]
03401: if c[xs] # 0 then goto 01451
03403: p - 1 -> p
03404: if p # 0 then goto 01410
03406: b -> c[w]
03407: return
03410: c - 1 -> c[x]
03411: if n/c goto 03403
03412: 0 -> c[w]
03413: b -> c[m]
03414: if 0 = s 8 then goto 01433
03416: p + 1 -> p
03417: if p # 13 then goto 01423
03421: jsb 03456
03422: if n/c goto 03426
03423: p + 1 -> p
03424: jsb 03456
03425: p - 1 -> p
03426: p - 1 -> p
03427: jsb 03456
03430: c -> a[w]
03431: b -> c[w]
03432: if n/c goto 03447
03433: 0 -> a[w]
03434: jsb 03454
03435: p + 1 -> p
03436: if p = 13 then goto 01441
03440: p + 1 -> p
03441: jsb 03454
03442: shift left a[w]
03443: a + c -> a[w]
03444: b exchange c[w]
03445: delayed rom 6
03446: jsb 03512
03447: delayed rom 6
03450: if n/c goto 03657
03451: if b[xs] = 0 then goto 01406
03453: if n/c goto 03412
03454: shift right c[wp]
03455: a + c -> c[wp]
03456: c -> a[wp]
03457: shift right c[wp]
03460: c + c -> c[wp]
03461: c + c -> c[wp]
03462: a - c -> c[wp]
03463: if 0 = s 8 then goto 01366
03465: 0 -> a[w]
03466: c -> a[x]
03467: a + c -> c[w]
03470: 0 -> c[x]
03471: return
03472: 0 -> a[w]
03473: a exchange c[m]
03474: b exchange c[w]
03475: delayed rom 8
03476: jsb 03415
03477: b exchange c[w]
03500: 1 -> s 8
03501: jsb 03572
03502: b exchange c[w]
03503: jsb 03661
03504: b exchange c[w]
03505: jsb 03560
03506: if p # 5 then goto 01503
03510: p <- 13
03511: load constant 7
03512: a exchange c[s]
03513: b exchange c[w]
03514: if n/c goto 03520
03515: a -> b[w]
03516: c - 1 -> c[s]
03517: if n/c goto 03534
03520: shift right a[wp]
03521: a exchange c[w]
03522: shift left a[ms]
03523: a exchange c[w]
03524: a - 1 -> a[s]
03525: if n/c goto 03515
03526: a exchange b[w]
03527: a + 1 -> a[p]
03530: delayed rom 6
03531: jsb 03654
03532: if n/c goto 03616
03533: shift right a[wp]
03534: a - 1 -> a[s]
03535: if n/c goto 03533
03536: 0 -> a[s]
03537: a + b -> a[w]
03540: a + 1 -> a[p]
03541: if n/c goto 03515
03542: shift right a[wp]
03543: a + 1 -> a[p]
03544: if n/c goto 03520
03545: a exchange c[w]
03546: delayed rom 8
03547: jsb 03415
03550: b exchange c[w]
03551: 0 -> c[w]
03552: a exchange c[w]
03553: delayed rom 6
03554: jsb 03455
03555: 0 -> c[m]
03556: if n/c goto 03474
03557: c + 1 -> c[s]
03560: a - b -> a[w]
03561: if n/c goto 03557
03562: a + b -> a[w]
03563: shift left a[w]
03564: shift right c[ms]
03565: b exchange c[w]
03566: p - 1 -> p
03567: return
03570: c + 1 -> c[x]
03571: shift right a[w]
03572: if c[xs] = 0 then goto 01633
03574: if a[s] # 0 then goto 01570
03576: 0 - c -> c[x]
03577: if c[xs] = 0 then goto 01621
03601: 0 -> c[m]
03602: 0 -> a[w]
03603: c + c -> c[x]
03604: if n/c goto 03623
03605: 0 -> c[wp]
03606: if c[s] # 0 then goto 01615
03610: c - 1 -> c[w]
03611: 0 -> c[xs]
03612: 1 -> s 11
03613: if 1 = s 4 then goto 01616
03615: 0 -> c[s]
03616: delayed rom 0
03617: if n/c goto 03470
03620: shift right a[w]
03621: c - 1 -> c[x]
03622: if n/c goto 03620
03623: 0 -> c[x]
03624: if c[s] = 0 then goto 01631
03626: a exchange b[w]
03627: a - b -> a[w]
03630: 0 - c - 1 -> c[x]
03631: 0 -> c[ms]
03632: return
03633: a exchange c[w]
03634: shift left a[wp]
03635: shift left a[wp]
03636: shift left a[wp]
03637: a exchange c[w]
03640: if n/c goto 03642
03641: c + 1 -> c[x]
03642: a - b -> a[w]
03643: if n/c goto 03641
03644: a + b -> a[w]
03645: c - 1 -> c[m]
03646: if n/c goto 03650
03647: if n/c goto 03624
03650: a exchange c[w]
03651: shift left a[x]
03652: a exchange c[w]
03653: shift left a[w]
03654: if 0 = s 8 then goto 01642
03656: if c[xs] # 0 then goto 01605
03660: if n/c goto 03642
03661: 0 -> c[w]
03662: if p = 12 then goto 01777
03664: c - 1 -> c[w]
03665: load constant 4
03666: c + 1 -> c[w]
03667: 0 -> c[s]
03670: shift right c[w]
03671: if p = 10 then goto 01743
03673: if p = 9 then goto 01705
03675: if p = 8 then goto 01717
03677: if p = 7 then goto 01727
03701: if p = 6 then goto 01734
03703: p + 1 -> p
03704: return
03705: p <- 7
03706: jsb 03740
03707: load constant 0
03710: load constant 8
03711: load constant 5
03712: load constant 3
03713: load constant 1
03714: load constant 7
03715: p <- 10
03716: return
03717: p <- 5
03720: jsb 03740
03721: load constant 3
03722: load constant 0
03723: load constant 8
03724: load constant 4
03725: p <- 9
03726: return
03727: p <- 3
03730: jsb 03740
03731: jsb 03740
03732: p <- 8
03733: return
03734: p <- 1
03735: jsb 03740
03736: p <- 7
03737: return
03740: load constant 3
03741: load constant 3
03742: return
03743: p <- 9
03744: load constant 3
03745: load constant 1
03746: load constant 0
03747: load constant 1
03750: load constant 7
03751: load constant 9
03752: load constant 8
03753: load constant 0
03754: load constant 4
03755: load constant 3
03756: p <- 11
03757: return
03760: a exchange c[w]
03761: p <- 1
03762: load constant 1
03763: c -> addr
03764: data register -> c 14
03765: decimal
03766: p <- 13
03767: c + c -> c[s]
03770: if n/c goto 03773
03771: load constant 9
03772: if n/c goto 03774
03773: load constant 0
03774: a exchange c[w]
03775: binary
03776: return
03777: p <- 11
04000: load constant 6
04001: load constant 9
04002: load constant 3
04003: load constant 1
04004: load constant 4
04005: load constant 7
04006: load constant 1
04007: load constant 8
04010: load constant 0
04011: load constant 5
04012: load constant 6
04013: p <- 12
04014: return
04015: 0 -> c[w]
04016: p <- 12
04017: load constant 2
04020: load constant 3
04021: load constant 0
04022: load constant 2
04023: load constant 5
04024: load constant 8
04025: load constant 5
04026: load constant 0
04027: load constant 9
04030: load constant 2
04031: load constant 9
04032: load constant 9
04033: load constant 4
04034: p <- 12
04035: return
04036: p <- 12
04037: if c[w] = 0 then goto 00163
04041: if c[s] # 0 then goto 00201
04043: if c[x] = 0 then goto 00237
04045: c + 1 -> c[x]
04046: 0 -> a[w]
04047: a - c -> a[m]
04050: if c[x] = 0 then goto 00255
04052: shift right a[wp]
04053: a -> b[s]
04054: p <- 13
04055: p - 1 -> p
04056: a - 1 -> a[s]
04057: if n/c goto 04055
04060: a exchange b[s]
04061: 0 -> c[ms]
04062: if n/c goto 04066
04063: shift right a[w]
04064: c + 1 -> c[p]
04065: a exchange b[s]
04066: a -> b[w]
04067: binary
04070: a + c -> a[s]
04071: m1 exch c
04072: a exchange c[s]
04073: shift left a[w]
04074: shift right a[w]
04075: c - 1 -> c[s]
04076: if n/c goto 04074
04077: decimal
04100: m1 exch c
04101: a + b -> a[w]
04102: shift left a[w]
04103: a - 1 -> a[s]
04104: if n/c goto 04063
04105: c -> a[s]
04106: a - 1 -> a[s]
04107: a + c -> a[s]
04110: if n/c goto 04114
04111: a exchange b[w]
04112: shift left a[w]
04113: if n/c goto 04126
04114: if p = 1 then goto 00111
04116: c + 1 -> c[s]
04117: p - 1 -> p
04120: a exchange b[w]
04121: a exchange b[s]
04122: shift left a[w]
04123: if n/c goto 04065
04124: c - 1 -> c[s]
04125: p + 1 -> p
04126: b exchange c[w]
04127: delayed rom 7
04130: jsb 04261
04131: shift right a[w]
04132: b exchange c[w]
04133: if n/c goto 04135
04134: a + b -> a[w]
04135: c - 1 -> c[p]
04136: if n/c goto 04134
04137: if c[s] # 0 then goto 00124
04141: if p = 12 then goto 00261
04143: 0 -> c[w]
04144: jsb 04333
04145: delayed rom 6
04146: jsb 04237
04147: 0 -> a[s]
04150: if 0 = s 7 then goto 00153
04152: 0 - c - 1 -> c[s]
04153: if 1 = s 10 then goto 00734
04155: if 1 = s 6 then goto 00325
04157: delayed rom 6
04160: jsb 04043
04161: delayed rom 0
04162: if n/c goto 04070
04163: if 0 = s 10 then goto 00172
04165: stack -> a
04166: if a[m] # 0 then goto 00174
04170: c -> stack
04171: a exchange c[w]
04172: delayed rom 2
04173: if n/c goto 04374
04174: if a[s] # 0 then goto 00170
04176: a exchange c[w]
04177: 0 -> c[w]
04200: if n/c goto 04161
04201: if 0 = s 10 then goto 00172
04203: stack -> a
04204: a -> b[w]
04205: if a[xs] # 0 then goto 00170
04207: a + 1 -> a[x]
04210: a - 1 -> a[x]
04211: shift left a[ms]
04212: if a[m] # 0 then goto 00233
04214: if a[x] # 0 then goto 00226
04216: a exchange c[s]
04217: c -> a[s]
04220: c + c -> c[s]
04221: c + c -> c[s]
04222: a + c -> c[s]
04223: if c[s] = 0 then goto 00227
04225: 1 -> s 4
04226: 0 -> c[s]
04227: b exchange c[w]
04230: c -> stack
04231: b exchange c[w]
04232: if n/c goto 04043
04233: if a[x] # 0 then goto 00210
04235: a exchange b[w]
04236: if n/c goto 04170
04237: c -> a[w]
04240: a - 1 -> a[p]
04241: if a[m] # 0 then goto 00245
04243: 0 -> c[w]
04244: if n/c goto 04153
04245: delayed rom 6
04246: jsb 04237
04247: delayed rom 6
04250: jsb 04124
04251: a + c -> a[s]
04252: a - 1 -> a[s]
04253: 0 -> c[x]
04254: if n/c goto 04052
04255: 1 -> s 7
04256: delayed rom 6
04257: jsb 04237
04260: if n/c goto 04253
04261: if c[x] = 0 then goto 00145
04263: c - 1 -> c[w]
04264: b exchange c[w]
04265: 0 -> b[m]
04266: jsb 04015
04267: a exchange c[w]
04270: a - c -> c[w]
04271: if b[xs] = 0 then goto 00274
04273: a - c -> c[w]
04274: a exchange c[w]
04275: b exchange c[w]
04276: if c[xs] = 0 then goto 00301
04300: 0 - c - 1 -> c[w]
04301: a exchange c[wp]
04302: p - 1 -> p
04303: shift left a[w]
04304: if p # 1 then goto 00302
04306: p <- 12
04307: if a[p] # 0 then goto 00322
04311: shift left a[m]
04312: a exchange c[w]
04313: a exchange c[s]
04314: delayed rom 6
04315: jsb 04067
04316: delayed rom 6
04317: jsb 04112
04320: 0 -> c[m]
04321: if n/c goto 04153
04322: a + 1 -> a[x]
04323: p - 1 -> p
04324: if n/c goto 04312
04325: b exchange c[w]
04326: jsb 04015
04327: b exchange c[w]
04330: delayed rom 6
04331: jsb 04134
04332: if n/c goto 04157
04333: p + 1 -> p
04334: c - 1 -> c[x]
04335: if p # 12 then goto 00333
04337: return
04340: p <- 1
04341: load constant 1
04342: c -> addr
04343: m1 -> c
04344: c -> data register 15
04345: delayed rom 4
04346: if n/c goto 04255
04347: nop
04350: d -> a
04351: delayed rom 4
04352: jsb 04242
04353: if c[m] = 0 then goto 00462
04355: if c[s] = 0 then goto 00362
04357: 1 -> s 7
04360: 1 -> s 10
04361: 0 -> c[s]
04362: delayed rom 6
04363: jsb 04124
04364: 0 -> a[s]
04365: delayed rom 5
04366: jsb 04041
04367: 0 -> s 11
04370: if p # 13 then goto 00466
04372: if c[w] # 0 then goto 00400
04374: stack -> a
04375: data register -> c 15
04376: c -> stack
04377: 0 -> c[w]
04400: 0 -> a[w]
04401: delayed rom 4
04402: jsb 04642
04403: 0 -> b[w]
04404: c -> a[m]
04405: if c[s] = 0 then goto 00417
04407: 1 -> s 4
04410: if 0 = s 13 then goto 00417
04412: if 0 = s 10 then goto 00417
04414: 0 -> s 10
04415: 1 -> s 7
04416: 0 -> s 4
04417: p <- 12
04420: if c[xs] = 0 then goto 00607
04422: if 0 = s 6 then goto 00620
04424: jsb 04730
04425: 0 -> c[w]
04426: a -> b[w]
04427: b exchange c[w]
04430: shift right a[w]
04431: a + 1 -> a[p]
04432: 0 - c -> c[wp]
04433: if n/c goto 04447
04434: a exchange b[w]
04435: a exchange c[w]
04436: delayed rom 6
04437: jsb 04637
04440: m1 exch c
04441: a exchange c[w]
04442: delayed rom 6
04443: jsb 04502
04444: c - 1 -> c[x]
04445: delayed rom 6
04446: jsb 04667
04447: b exchange c[w]
04450: a exchange b[w]
04451: data register -> c 15
04452: a exchange c[w]
04453: delayed rom 6
04454: jsb 04526
04455: 0 -> a[s]
04456: if c[xs] # 0 then goto 00620
04460: a exchange b[w]
04461: if n/c goto 04614
04462: c + 1 -> c[xs]
04463: a exchange c[s]
04464: if a[w] # 0 then goto 00365
04466: a exchange b[w]
04467: stack -> a
04470: b exchange c[w]
04471: c -> stack
04472: b exchange c[w]
04473: delayed rom 6
04474: jsb 04505
04475: delayed rom 11
04476: jsb 04533
04477: a exchange b[w]
04500: a exchange c[w]
04501: data register -> c 15
04502: delayed rom 6
04503: jsb 04441
04504: stack -> a
04505: c -> stack
04506: m1 -> c
04507: if n/c goto 04405
04510: a -> b[w]
04511: if b[w] = 0 then goto 00526
04513: a - 1 -> a[p]
04514: if a[w] # 0 then goto 00612
04516: a exchange b[w]
04517: if 0 = s 6 then goto 00524
04521: jsb 04721
04522: 0 -> c[w]
04523: if n/c goto 04526
04524: delayed rom 10
04525: jsb 04442
04526: a exchange c[w]
04527: 0 -> c[w]
04530: delayed rom 8
04531: jsb 04734
04532: b exchange c[w]
04533: delayed rom 10
04534: jsb 04442
04535: c + c -> c[w]
04536: shift right c[w]
04537: b exchange c[w]
04540: if 0 = s 10 then goto 00554
04542: jsb 04731
04543: b exchange c[w]
04544: a exchange c[w]
04545: a - c -> c[w]
04546: a exchange c[w]
04547: b exchange c[w]
04550: 0 -> c[w]
04551: delayed rom 6
04552: jsb 04637
04553: 0 -> a[s]
04554: if 0 = s 7 then goto 00560
04556: jsb 04731
04557: a + b -> a[w]
04560: 0 -> c[s]
04561: if 1 = s 0 then goto 00575
04563: c + 1 -> c[x]
04564: c + 1 -> c[x]
04565: delayed rom 6
04566: jsb 04534
04567: 0 -> a[s]
04570: if 1 = s 14 then goto 00575
04572: a -> b[w]
04573: shift right b[w]
04574: a - b -> a[w]
04575: delayed rom 6
04576: jsb 04654
04577: if 1 = s 13 then goto 00161
04601: stack -> a
04602: c -> stack
04603: 0 -> a[s]
04604: a exchange c[w]
04605: delayed rom 0
04606: if n/c goto 04470
04607: if c[x] = 0 then goto 00510
04611: a exchange b[w]
04612: if 1 = s 6 then goto 00172
04614: delayed rom 6
04615: jsb 04565
04616: 0 -> a[s]
04617: jsb 04721
04620: p <- 12
04621: m1 exch c
04622: m1 -> c
04623: 0 -> c[ms]
04624: c + 1 -> c[x]
04625: if c[x] = 0 then goto 00635
04627: c + 1 -> c[s]
04630: p - 1 -> p
04631: if p # 6 then goto 00624
04633: m1 -> c
04634: if n/c goto 04532
04635: m1 exch c
04636: 0 -> c[w]
04637: c + 1 -> c[s]
04640: shift right c[w]
04641: if n/c goto 04656
04642: a exchange c[w]
04643: m1 exch c
04644: c + 1 -> c[p]
04645: c -> a[s]
04646: m1 exch c
04647: shift right b[w]
04650: shift right b[w]
04651: a - 1 -> a[s]
04652: if n/c goto 04647
04653: 0 -> a[s]
04654: a + b -> a[w]
04655: a exchange c[w]
04656: a -> b[w]
04657: a - c -> a[w]
04660: if n/c goto 04642
04661: m1 exch c
04662: c + 1 -> c[s]
04663: m1 exch c
04664: a exchange b[w]
04665: shift left a[w]
04666: p - 1 -> p
04667: if p # 6 then goto 00656
04671: b exchange c[w]
04672: delayed rom 6
04673: jsb 04534
04674: if n/c goto 04676
04675: shift right a[wp]
04676: a - 1 -> a[s]
04677: if n/c goto 04675
04700: 0 -> a[s]
04701: 0 -> c[x]
04702: m1 exch c
04703: p <- 7
04704: b exchange c[w]
04705: jsb 04740
04706: b exchange c[w]
04707: if n/c goto 04711
04710: a + b -> a[w]
04711: c - 1 -> c[p]
04712: if n/c goto 04710
04713: shift right a[w]
04714: 0 -> c[p]
04715: if c[m] = 0 then goto 00530
04717: p + 1 -> p
04720: if n/c goto 04704
04721: if 1 = s 10 then goto 00725
04723: 1 -> s 10
04724: return
04725: 0 -> s 10
04726: return
04727: shift right a[w]
04730: c + 1 -> c[x]
04731: if c[x] # 0 then goto 00727
04733: return
04734: a exchange b[w]
04735: stack -> a
04736: delayed rom 7
04737: if n/c goto 04552
04740: 0 -> c[w]
04741: c - 1 -> c[w]
04742: 0 -> c[s]
04743: if p = 12 then goto 00766
04745: if p = 11 then goto 01007
04747: if p = 10 then goto 01017
04751: if p = 9 then goto 01025
04753: if p = 8 then goto 01031
04755: p <- 0
04756: load constant 7
04757: p <- 7
04760: return
04761: nop
04762: nop
04763: nop
04764: nop
04765: nop
04766: p <- 10
04767: load constant 6
04770: load constant 6
04771: load constant 8
04772: load constant 6
04773: load constant 5
04774: load constant 2
04775: load constant 4
04776: load constant 9
04777: load constant 1
05000: load constant 1
05001: load constant 6
05002: if n/c goto 05061
05003: load constant 6
05004: if p = 0 then goto 00756
05006: if n/c goto 05003
05007: p <- 8
05010: jsb 05003
05011: p <- 0
05012: load constant 5
05013: p <- 4
05014: load constant 8
05015: p <- 11
05016: return
05017: p <- 6
05020: jsb 05003
05021: p <- 0
05022: load constant 9
05023: p <- 10
05024: return
05025: p <- 4
05026: jsb 05003
05027: p <- 9
05030: return
05031: p <- 2
05032: jsb 05003
05033: p <- 8
05034: return
05035: 0 -> c[w]
05036: p <- 12
05037: load constant 4
05040: load constant 5
05041: if n/c goto 05061
05042: p <- 12
05043: 0 -> c[w]
05044: load constant 7
05045: load constant 8
05046: load constant 5
05047: load constant 3
05050: load constant 9
05051: load constant 8
05052: load constant 1
05053: load constant 6
05054: load constant 3
05055: load constant 3
05056: load constant 9
05057: load constant 7
05060: load constant 5
05061: p <- 12
05062: return
05063: 1 -> s 13
05064: 1 -> s 6
05065: 1 -> s 10
05066: stack -> a
05067: if n/c goto 05071
05070: c -> a[w]
05071: delayed rom 4
05072: jsb 05242
05073: delayed rom 8
05074: jsb 05340
05075: a exchange c[w]
05076: 0 -> a[w]
05077: 0 -> b[w]
05100: a exchange c[m]
05101: if c[s] = 0 then goto 01110
05103: 1 -> s 7
05104: if 1 = s 10 then goto 01107
05106: 1 -> s 4
05107: 0 -> c[s]
05110: b exchange c[w]
05111: if 1 = s 0 then goto 01216
05113: if 0 = s 14 then goto 01121
05115: a exchange c[w]
05116: c -> a[w]
05117: shift right c[w]
05120: a - c -> a[w]
05121: jsb 05035
05122: b exchange c[w]
05123: c - 1 -> c[x]
05124: if c[xs] # 0 then goto 01132
05126: c - 1 -> c[x]
05127: if n/c goto 05132
05130: c + 1 -> c[x]
05131: shift right a[w]
05132: b exchange c[w]
05133: m1 exch c
05134: m1 -> c
05135: c + c -> c[w]
05136: c + c -> c[w]
05137: c + c -> c[w]
05140: shift right c[w]
05141: b exchange c[w]
05142: if c[xs] # 0 then goto 01163
05144: delayed rom 7
05145: jsb 05172
05146: 0 -> c[w]
05147: b exchange c[w]
05150: m1 -> c
05151: c + c -> c[w]
05152: shift left a[w]
05153: if 0 = s 0 then goto 01157
05155: shift right a[w]
05156: shift right c[w]
05157: b exchange c[w]
05160: a - b -> a[w]
05161: if n/c goto 05174
05162: a + b -> a[w]
05163: b exchange c[w]
05164: m1 -> c
05165: b exchange c[w]
05166: if 0 = s 0 then goto 01226
05170: if c[x] # 0 then goto 01225
05172: shift left a[w]
05173: if n/c goto 05226
05174: if 0 = s 10 then goto 01205
05176: 0 -> s 10
05177: if 1 = s 4 then goto 01203
05201: 1 -> s 4
05202: if n/c goto 05160
05203: 0 -> s 4
05204: if n/c goto 05160
05205: 1 -> s 10
05206: if 0 = s 6 then goto 01177
05210: if 0 = s 7 then goto 01214
05212: 0 -> s 7
05213: if n/c goto 05160
05214: 1 -> s 7
05215: if n/c goto 05160
05216: jsb 05042
05217: if n/c goto 05133
05220: a exchange b[w]
05221: a - b -> a[w]
05222: delayed rom 9
05223: jsb 05321
05224: if n/c goto 05233
05225: c + 1 -> c[x]
05226: if c[xs] # 0 then goto 01235
05230: a - b -> a[w]
05231: if n/c goto 05220
05232: a + b -> a[w]
05233: delayed rom 6
05234: jsb 05237
05235: 0 -> a[s]
05236: if 1 = s 0 then goto 01252
05240: b exchange c[w]
05241: m1 -> c
05242: b exchange c[w]
05243: delayed rom 6
05244: jsb 05134
05245: 0 -> a[s]
05246: m1 exch c
05247: jsb 05042
05250: delayed rom 6
05251: jsb 05101
05252: c - 1 -> c[x]
05253: m1 exch c
05254: m1 -> c
05255: c + 1 -> c[x]
05256: if n/c goto 05316
05257: shift left a[w]
05260: if n/c goto 05320
05261: 0 -> c[w]
05262: 0 -> a[w]
05263: a + 1 -> a[p]
05264: delayed rom 6
05265: jsb 05254
05266: if n/c goto 05311
05267: p <- 12
05270: m1 -> c
05271: if 1 = s 10 then goto 01510
05273: if 0 = s 13 then goto 01264
05275: b exchange c[w]
05276: data register -> c 15
05277: delayed rom 11
05300: jsb 05171
05301: c -> stack
05302: data register -> c 15
05303: a exchange b[w]
05304: delayed rom 6
05305: jsb 05041
05306: if 0 = s 4 then goto 01311
05310: 0 - c - 1 -> c[s]
05311: delayed rom 0
05312: if n/c goto 05070
05313: p - 1 -> p
05314: if p = 6 then goto 01267
05316: c + 1 -> c[x]
05317: if n/c goto 05313
05320: 0 -> c[w]
05321: b exchange c[w]
05322: delayed rom 9
05323: jsb 05340
05324: b exchange c[w]
05325: delayed rom 7
05326: jsb 05160
05327: if p # 6 then goto 01322
05331: b exchange c[w]
05332: m1 exch c
05333: shift right a[w]
05334: shift right a[w]
05335: 0 -> c[w]
05336: p <- 12
05337: load constant 1
05340: m1 exch c
05341: p <- 13
05342: load constant 6
05343: if n/c goto 05356
05344: shift right a[wp]
05345: shift right a[wp]
05346: a - 1 -> a[s]
05347: if n/c goto 05344
05350: 0 -> a[s]
05351: m1 exch c
05352: a exchange c[w]
05353: a - c -> c[w]
05354: a + b -> a[w]
05355: m1 exch c
05356: a -> b[w]
05357: c -> a[s]
05360: c - 1 -> c[p]
05361: if n/c goto 05346
05362: a exchange c[w]
05363: shift left a[m]
05364: a exchange c[w]
05365: if c[m] = 0 then goto 01374
05367: c - 1 -> c[s]
05370: 0 -> a[s]
05371: shift right a[w]
05372: if n/c goto 05356
05373: c + 1 -> c[x]
05374: c - 1 -> c[s]
05375: if n/c goto 05373
05376: 0 -> c[s]
05377: m1 exch c
05400: a exchange c[w]
05401: a - 1 -> a[w]
05402: m1 -> c
05403: if 1 = s 10 then goto 01407
05405: 0 - c -> c[x]
05406: a exchange b[w]
05407: if b[w] = 0 then goto 01473
05411: delayed rom 6
05412: jsb 05534
05413: 0 -> a[s]
05414: if 0 = s 6 then goto 01264
05416: a exchange c[w]
05417: c -> data register 14
05420: a exchange c[w]
05421: a exchange b[w]
05422: delayed rom 6
05423: jsb 05505
05424: jsb 05533
05425: b exchange c[w]
05426: a exchange b[w]
05427: if 0 = s 13 then goto 01460
05431: data register -> c 15
05432: a exchange c[w]
05433: delayed rom 6
05434: jsb 05526
05435: a exchange c[w]
05436: m1 exch c
05437: a + c -> c[x]
05440: c -> stack
05441: m1 -> c
05442: a exchange c[w]
05443: jsb 05567
05444: stack -> a
05445: c -> stack
05446: data register -> c 15
05447: a exchange c[s]
05450: data register -> c 14
05451: a exchange c[w]
05452: m1 exch c
05453: delayed rom 6
05454: jsb 05501
05455: delayed rom 6
05456: jsb 05443
05457: if n/c goto 05531
05460: m1 -> c
05461: a exchange c[w]
05462: a - c -> c[x]
05463: a exchange c[w]
05464: data register -> c 14
05465: a exchange c[w]
05466: delayed rom 6
05467: jsb 05534
05470: 0 -> c[s]
05471: delayed rom 10
05472: if n/c goto 05664
05473: 0 -> c[w]
05474: if 1 = s 6 then goto 01504
05476: c - 1 -> c[w]
05477: 0 -> c[xs]
05500: 1 -> s 11
05501: 0 -> c[s]
05502: delayed rom 0
05503: if n/c goto 05470
05504: if 0 = s 13 then goto 01261
05506: 0 -> c[w]
05507: if n/c goto 05527
05510: if 1 = s 6 then goto 01517
05512: a exchange b[w]
05513: delayed rom 6
05514: jsb 05565
05515: delayed rom 10
05516: if n/c goto 05664
05517: if 0 = s 13 then goto 01261
05521: b exchange c[w]
05522: a exchange b[w]
05523: data register -> c 15
05524: delayed rom 6
05525: jsb 05441
05526: jsb 05571
05527: c -> stack
05530: data register -> c 15
05531: delayed rom 10
05532: if n/c goto 05706
05533: 0 -> b[w]
05534: b exchange c[x]
05535: p <- 12
05536: b -> c[w]
05537: c + c -> c[x]
05540: if n/c goto 05555
05541: b -> c[w]
05542: delayed rom 9
05543: jsb 05727
05544: a + 1 -> a[p]
05545: if n/c goto 05550
05546: p + 1 -> p
05547: if n/c goto 05544
05550: delayed rom 6
05551: jsb 05512
05552: 0 -> b[w]
05553: delayed rom 6
05554: if n/c goto 05667
05555: b -> c[w]
05556: c - 1 -> c[x]
05557: if n/c goto 05562
05560: b -> c[w]
05561: if n/c goto 05544
05562: p - 1 -> p
05563: if p # 0 then goto 01556
05565: b -> c[w]
05566: if n/c goto 05552
05567: delayed rom 6
05570: jsb 05443
05571: if 0 = s 7 then goto 01574
05573: 0 - c - 1 -> c[s]
05574: delayed rom 5
05575: if n/c goto 05436
05576: rotate a left
05577: rotate a left
05600: rotate a left
05601: rotate a left
05602: rotate a left
05603: rotate a left
05604: return
05605: p <- 1
05606: c -> addr
05607: b exchange c[w]
05610: data register -> c 0
05611: b exchange c[ms]
05612: b -> c[x]
05613: c + 1 -> c[xs]
05614: c + 1 -> c[xs]
05615: c + 1 -> c[xs]
05616: decimal
05617: 0 - c - 1 -> c[xs]
05620: binary
05621: if n/c goto 05626
05622: p + 1 -> p
05623: p + 1 -> p
05624: shift left a[wp]
05625: shift left a[wp]
05626: c - 1 -> c[xs]
05627: if n/c goto 05622
05630: data register -> c 0
05631: a exchange c[w]
05632: rotate a left
05633: rotate a left
05634: shift right a[wp]
05635: shift right a[wp]
05636: c -> a[p]
05637: p - 1 -> p
05640: c -> a[p]
05641: b -> c[w]
05642: if n/c goto 05652
05643: c -> a[w]
05644: c -> addr
05645: data register -> c 0
05646: p <- 11
05647: a exchange c[wp]
05650: rotate a left
05651: rotate a left
05652: a exchange c[w]
05653: p <- 0
05654: c -> data
05655: a exchange c[w]
05656: c - 1 -> c[p]
05657: if n/c goto 05643
05660: delayed rom 2
05661: if n/c goto 05770
05662: b exchange c[w]
05663: m1 exch c
05664: m2 -> c
05665: if c[x] = 0 then goto 01771
05667: p <- 1
05670: p - 1 -> p
05671: p - 1 -> p
05672: c - 1 -> c[xs]
05673: if n/c goto 05670
05674: c -> a[w]
05675: c -> addr
05676: data register -> c 0
05677: a exchange c[w]
05700: shift left a[wp]
05701: shift left a[wp]
05702: p <- 1
05703: c -> a[wp]
05704: if n/c goto 05721
05705: c -> addr
05706: p <- 1
05707: b exchange c[wp]
05710: data register -> c 0
05711: a exchange c[wp]
05712: jsb 05576
05713: jsb 05576
05714: c -> addr
05715: b -> c[wp]
05716: a exchange c[w]
05717: c -> data
05720: b -> c[w]
05721: p <- 0
05722: c - 1 -> c[wp]
05723: if n/c goto 05705
05724: a exchange c[w]
05725: c -> addr
05726: shift right c[w]
05727: shift right c[w]
05730: c -> data
05731: m1 -> c
05732: b exchange c[w]
05733: 0 -> s 11
05734: delayed rom 2
05735: if n/c goto 05773
05736: delayed rom 4
05737: jsb 05635
05740: shift right a[w]
05741: load constant 3
05742: p <- 0
05743: c - 1 -> c[p]
05744: a - 1 -> a[xs]
05745: if n/c goto 05743
05746: c -> data
05747: if n/c goto 05771
05750: if 0 = s 12 then goto 01755
05752: delayed rom 7
05753: jsb 05760
05754: if n/c goto 05757
05755: delayed rom 4
05756: jsb 05400
05757: delayed rom 2
05760: jsb 05771
05761: display off
05762: display toggle
05763: 0 -> c[w]
05764: p <- 2
05765: load constant 6
05766: c - 1 -> c[w]
05767: if n/c goto 05766
05770: display off
05771: delayed rom 0
05772: if n/c goto 05461
05773: nop
05774: nop
05775: nop
05776: nop
05777: nop
06000: if n/c goto 06034
06001: if n/c goto 06030
06002: if n/c goto 06034
06003: if n/c goto 06034
06004: a + 1 -> a[xs]
06005: a + 1 -> a[xs]
06006: if n/c goto 06032
06007: if n/c goto 06040
06010: if n/c goto 06041
06011: if n/c goto 06247
06012: if n/c goto 06243
06013: if n/c goto 06224
06014: if n/c goto 06235
06015: if n/c goto 06237
06016: if n/c goto 06220
06017: delayed rom 0
06020: if n/c goto 06061
06021: m1 -> c
06022: c -> a[x]
06023: 0 -> a[xs]
06024: b -> c[w]
06025: p <- 12
06026: 0 -> s 11
06027: a -> rom address
06030: delayed rom 14
06031: if n/c goto 06163
06032: delayed rom 14
06033: if n/c goto 06041
06034: decimal
06035: shift left a[x]
06036: delayed rom 13
06037: a -> rom address
06040: 1 -> s 8
06041: p <- 1
06042: a exchange c[w]
06043: load constant 15
06044: p <- 1
06045: 0 -> a[w]
06046: c -> a[wp]
06047: if a[s] # 0 then goto 00057
06051: shift left a[w]
06052: shift left a[w]
06053: c -> a[wp]
06054: shift left a[w]
06055: shift left a[w]
06056: if n/c goto 06046
06057: m2 -> c
06060: if c[x] # 0 then goto 00064
06062: delayed rom 0
06063: jsb 06017
06064: p <- 1
06065: p - 1 -> p
06066: p - 1 -> p
06067: c - 1 -> c[xs]
06070: if n/c goto 06065
06071: c -> addr
06072: b exchange c[w]
06073: data register -> c 0
06074: b exchange c[w]
06075: a exchange b[w]
06076: if a >= b[p] then goto 00153
06100: p + 1 -> p
06101: p + 1 -> p
06102: if p # 0 then goto 00076
06104: if n/c goto 06141
06105: c -> addr
06106: a exchange c[w]
06107: data register -> c 0
06110: a exchange c[w]
06111: if a[w] # 0 then goto 00114
06113: if n/c goto 06141
06114: p <- 1
06115: if a >= b[p] then goto 00153
06117: p <- 3
06120: if a >= b[p] then goto 00153
06122: p <- 5
06123: if a >= b[p] then goto 00153
06125: p <- 7
06126: if a >= b[p] then goto 00153
06130: p <- 9
06131: if a >= b[p] then goto 00153
06133: p <- 11
06134: if a >= b[p] then goto 00153
06136: p <- 13
06137: if a >= b[p] then goto 00153
06141: p <- 0
06142: c - 1 -> c[p]
06143: if n/c goto 06105
06144: if 1 = s 6 then goto 00664
06146: load constant 13
06147: 1 -> s 6
06150: if n/c goto 06105
06151: p + 1 -> p
06152: if n/c goto 06100
06153: p - 1 -> p
06154: a - b -> a[p]
06155: if a[p] # 0 then goto 00151
06157: c + 1 -> c[xs]
06160: p - 1 -> p
06161: p - 1 -> p
06162: if p # 12 then goto 00157
06164: c + 1 -> c[xs]
06165: c + 1 -> c[xs]
06166: c + 1 -> c[xs]
06167: decimal
06170: 0 - c - 1 -> c[xs]
06171: c -> a[w]
06172: m2 -> c
06173: if 0 = s 8 then goto 00214
06175: a exchange c[w]
06176: p <- 11
06177: shift left a[wp]
06200: shift left a[wp]
06201: shift left a[wp]
06202: a exchange c[w]
06203: if 1 = s 2 then goto 00214
06205: 1 -> s 2
06206: if 1 = s 1 then goto 00214
06210: 0 -> s 15
06211: if 1 = s 15 then goto 00210
06213: 0 -> c[w]
06214: a exchange c[x]
06215: m2 exch c
06216: delayed rom 0
06217: if n/c goto 06055
06220: jsb 06264
06221: delayed rom 5
06222: jsb 06015
06223: if n/c goto 06230
06224: jsb 06264
06225: 0 - c - 1 -> c[s]
06226: delayed rom 6
06227: jsb 06173
06230: delayed rom 5
06231: jsb 06036
06232: if 1 = s 11 then goto 00664
06234: if n/c goto 06244
06235: jsb 06264
06236: if n/c goto 06226
06237: jsb 06264
06240: delayed rom 6
06241: jsb 06037
06242: if n/c goto 06230
06243: jsb 06264
06244: c -> data
06245: delayed rom 0
06246: if n/c goto 06061
06247: jsb 06264
06250: if 0 = s 9 then goto 00253
06252: c -> stack
06253: a exchange b[w]
06254: p <- 1
06255: load constant 1
06256: c -> addr
06257: data register -> c 15
06260: jsb 06352
06261: c -> data register 15
06262: delayed rom 0
06263: if n/c goto 06067
06264: if 1 = s 11 then goto 00271
06266: m1 -> c
06267: p <- 1
06270: 0 -> c[p]
06271: c -> addr
06272: data register -> c 0
06273: a exchange b[w]
06274: a exchange c[w]
06275: decimal
06276: 0 -> s 11
06277: return
06300: 0 -> c[w]
06301: m2 exch c
06302: if n/c goto 06017
06303: cpu woodstock
06304: 0 -> c[w]
06305: m1 exch c
06306: 0 -> c[w]
06307: m2 exch c
06310: clear s
06311: binary
06312: delayed rom 4
06313: jsb 06235
06314: c -> a[w]
06315: jsb 06360
06316: a - c -> a[m]
06317: if a[m] # 0 then goto 00334
06321: p <- 0
06322: 0 -> c[p]
06323: jsb 06352
06324: c -> data register 14
06325: 0 -> c[x]
06326: p <- 1
06327: load constant 1
06330: c -> addr
06331: clear data registers
06332: delayed rom 0
06333: if n/c goto 06061
06334: 0 -> c[w]
06335: p <- 1
06336: load constant 3
06337: p <- 1
06340: delayed rom 2
06341: jsb 06372
06342: 0 -> c[w]
06343: jsb 06360
06344: p <- 2
06345: load constant 2
06346: jsb 06352
06347: c -> data register 14
06350: delayed rom 2
06351: if n/c goto 06374
06352: a exchange c[w]
06353: p <- 1
06354: load constant 2
06355: c -> addr
06356: a exchange c[w]
06357: return
06360: p <- 12
06361: load constant 3
06362: load constant 4
06363: load constant 9
06364: load constant 3
06365: load constant 4
06366: load constant 2
06367: load constant 8
06370: load constant 4
06371: return
06372: nop
06373: nop
06374: nop
06375: nop
06376: nop
06377: nop
06400: if n/c goto 06700
06401: if n/c goto 06707
06402: if n/c goto 06427
06403: if n/c goto 06431
06404: if n/c goto 06757
06405: if n/c goto 06705
06406: if n/c goto 06526
06407: 1 -> s 8
06410: 1 -> s 10
06411: if n/c goto 06622
06412: if n/c goto 06622
06413: if n/c goto 06622
06414: if n/c goto 06622
06415: if n/c goto 06622
06416: if n/c goto 06622
06417: delayed rom 6
06420: if n/c goto 06735
06421: delayed rom 6
06422: jsb 06515
06423: delayed rom 0
06424: if n/c goto 06470
06425: 0 -> c[s]
06426: if n/c goto 06423
06427: delayed rom 15
06430: if n/c goto 06713
06431: delayed rom 15
06432: if n/c goto 06646
06433: delayed rom 0
06434: if n/c goto 06501
06435: delayed rom 2
06436: if n/c goto 06775
06437: nop
06440: if n/c goto 06702
06441: if n/c goto 06607
06442: if n/c goto 06501
06443: if n/c goto 06512
06444: if n/c goto 06523
06445: if n/c goto 06522
06446: if n/c goto 06524
06447: if n/c goto 06517
06450: if n/c goto 06516
06451: if n/c goto 06510
06452: if n/c goto 06714
06453: if n/c goto 06555
06454: if n/c goto 06560
06455: if n/c goto 06544
06456: if n/c goto 06537
06457: if n/c goto 06435
06460: if n/c goto 06703
06461: if n/c goto 06613
06462: if n/c goto 06421
06463: if n/c goto 06425
06464: if n/c goto 06603
06465: if n/c goto 06602
06466: if n/c goto 06604
06467: if n/c goto 06504
06470: if n/c goto 06577
06471: if n/c goto 06506
06472: if n/c goto 06730
06473: if n/c goto 06566
06474: if n/c goto 06567
06475: if n/c goto 06546
06476: if n/c goto 06541
06477: delayed rom 3
06500: if n/c goto 06400
06501: delayed rom 6
06502: jsb 06661
06503: if n/c goto 06423
06504: delayed rom 7
06505: if n/c goto 06472
06506: delayed rom 8
06507: if n/c goto 06750
06510: delayed rom 10
06511: if n/c goto 06463
06512: stack -> a
06513: c -> stack
06514: a exchange c[w]
06515: 1 -> s 10
06516: 1 -> s 6
06517: 1 -> s 8
06520: delayed rom 8
06521: if n/c goto 06436
06522: 1 -> s 10
06523: 1 -> s 6
06524: delayed rom 10
06525: if n/c goto 06470
06526: 0 -> c[w]
06527: c -> addr
06530: c -> data register 10
06531: c -> data register 11
06532: c -> data register 12
06533: c -> data register 13
06534: c -> data register 14
06535: c -> data register 15
06536: if n/c goto 06553
06537: d -> a
06540: a - c -> c[w]
06541: if c[w] = 0 then goto 00553
06543: if n/c goto 06550
06544: d -> a
06545: a - c -> c[w]
06546: if c[w] # 0 then goto 00553
06550: delayed rom 0
06551: jsb 06417
06552: 0 -> s 11
06553: delayed rom 0
06554: if n/c goto 06461
06555: d -> a
06556: 1 -> s 13
06557: if n/c goto 06562
06560: d -> a
06561: a exchange c[w]
06562: 0 - c - 1 -> c[s]
06563: delayed rom 6
06564: jsb 06573
06565: if n/c goto 06567
06566: 0 - c - 1 -> c[s]
06567: if c[m] # 0 then goto 00574
06571: if 1 = s 13 then goto 00553
06573: if n/c goto 06550
06574: if c[s] = 0 then goto 00553
06576: if n/c goto 06550
06577: 1 -> s 8
06600: delayed rom 7
06601: if n/c goto 06545
06602: 1 -> s 10
06603: 1 -> s 6
06604: 1 -> s 13
06605: delayed rom 9
06606: if n/c goto 06400
06607: jsb 06741
06610: 0 -> c[wp]
06611: a exchange c[x]
06612: if n/c goto 06423
06613: jsb 06741
06614: 0 -> a[x]
06615: delayed rom 6
06616: jsb 06637
06617: c - 1 -> c[x]
06620: a exchange c[m]
06621: if n/c goto 06423
06622: 0 -> c[w]
06623: binary
06624: c -> addr
06625: data register -> c 0
06626: p <- 12
06627: p - 1 -> p
06630: shift right c[m]
06631: if p # 4 then goto 00627
06633: if c[xs] = 0 then goto 00636
06635: 0 -> c[w]
06636: if 1 = s 10 then goto 00767
06640: jsb 06657
06641: c -> a[m]
06642: load constant 3
06643: load constant 0
06644: if a >= c[m] then goto 00664
06646: if n/c goto 06651
06647: binary
06650: c + 1 -> c[x]
06651: decimal
06652: a - 1 -> a[m]
06653: if n/c goto 06647
06654: 1 -> s 11
06655: delayed rom 12
06656: a -> rom address
06657: if c[x] = 0 then goto 00666
06661: c - 1 -> c[x]
06662: if c[x] = 0 then goto 00667
06664: delayed rom 2
06665: if n/c goto 06774
06666: shift right c[m]
06667: return
06670: shift right c[m]
06671: jsb 06662
06672: shift right c[w]
06673: shift right c[w]
06674: c - 1 -> c[xs]
06675: shift right c[w]
06676: delayed rom 12
06677: if n/c goto 06444
06700: delayed rom 0
06701: if n/c goto 06440
06702: 1 -> s 8
06703: delayed rom 6
06704: if n/c goto 06744
06705: delayed rom 0
06706: if n/c goto 06404
06707: b -> c[w]
06710: c -> stack
06711: 0 -> s 9
06712: delayed rom 0
06713: if n/c goto 06462
06714: jsb 06724
06715: p <- 1
06716: load constant 1
06717: c -> addr
06720: data register -> c 15
06721: b exchange c[w]
06722: delayed rom 12
06723: if n/c goto 06654
06724: if 0 = s 9 then goto 00727
06726: c -> stack
06727: return
06730: jsb 06724
06731: delayed rom 10
06732: jsb 06442
06733: c + c -> c[w]
06734: c + c -> c[w]
06735: shift right c[w]
06736: c + 1 -> c[m]
06737: 0 -> c[x]
06740: if n/c goto 06721
06741: c -> a[w]
06742: if c[xs] = 0 then goto 00746
06744: c + 1 -> c[x]
06745: return
06746: c + 1 -> c[x]
06747: if c[x] = 0 then goto 00756
06751: c - 1 -> c[x]
06752: shift left a[m]
06753: p - 1 -> p
06754: if a[m] # 0 then goto 00747
06756: return
06757: if 0 = s 12 then goto 00762
06761: 1 -> s 14
06762: delayed rom 4
06763: jsb 06635
06764: 0 -> c[w]
06765: c -> data register 15
06766: if n/c goto 06711
06767: if c[s] = 0 then goto 00670
06771: jsb 06657
06772: shift right c[w]
06773: shift right c[w]
06774: shift right c[w]
06775: b exchange c[w]
06776: m2 -> c
06777: delayed rom 4
07000: jsb 07363
07001: rotate a left
07002: rotate a left
07003: 0 -> a[xs]
07004: b exchange c[w]
07005: decimal
07006: delayed rom 4
07007: if n/c goto 07313
07010: delayed rom 0
07011: if n/c goto 07101
07012: delayed rom 0
07013: if n/c goto 07067
07014: a exchange c[x]
07015: c -> a[w]
07016: p <- 0
07017: load constant 10
07020: decimal
07021: if a >= c[x] then goto 01025
07023: b -> c[w]
07024: return
07025: shift left a[w]
07026: b -> c[w]
07027: a -> rom address
07030: delayed rom 5
07031: if n/c goto 07072
07032: if n/c goto 07070
07033: if n/c goto 07144
07034: if n/c goto 07145
07035: if n/c goto 07120
07036: if n/c goto 07125
07037: delayed rom 3
07040: if n/c goto 07001
07041: jsb 07014
07042: delayed rom 4
07043: jsb 07235
07044: p <- 13
07045: load constant 3
07046: c - 1 -> c[s]
07047: a - 1 -> a[xs]
07050: if n/c goto 07046
07051: shift left a[x]
07052: shift left a[x]
07053: a exchange c[xs]
07054: c -> data register 14
07055: b exchange c[w]
07056: delayed rom 13
07057: if n/c goto 07321
07060: stack -> a
07061: c -> stack
07062: a exchange c[w]
07063: if n/c goto 07056
07064: delayed rom 4
07065: if n/c goto 07260
07066: delayed rom 5
07067: if n/c goto 07145
07070: delayed rom 15
07071: if n/c goto 07227
07072: b exchange c[w]
07073: m2 -> c
07074: if 1 = s 1 then goto 01100
07076: if 0 = s 2 then goto 00300
07100: 0 -> c[s]
07101: shift right c[w]
07102: shift right c[w]
07103: shift right c[w]
07104: if c[w] # 0 then goto 01755
07106: delayed rom 0
07107: if n/c goto 07053
07110: delayed rom 11
07111: if n/c goto 07350
07112: if n/c goto 07060
07113: if n/c goto 07166
07114: if n/c goto 07161
07115: if n/c goto 07142
07116: if n/c goto 07030
07117: if n/c goto 07157
07120: delayed rom 6
07121: jsb 07036
07122: if n/c goto 07150
07123: delayed rom 6
07124: if n/c goto 07026
07125: decimal
07126: b -> c[w]
07127: delayed rom 6
07130: jsb 07117
07131: if n/c goto 07150
07132: if n/c goto 07064
07133: if n/c goto 07066
07134: if n/c goto 07110
07135: nop
07136: if n/c goto 07140
07137: if n/c goto 07157
07140: delayed rom 5
07141: if n/c goto 07071
07142: delayed rom 2
07143: if n/c goto 07376
07144: 0 - c - 1 -> c[s]
07145: stack -> a
07146: delayed rom 6
07147: jsb 07173
07150: delayed rom 0
07151: if n/c goto 07070
07152: if n/c goto 07123
07153: if n/c goto 07170
07154: 1 -> s 13
07155: if n/c goto 07173
07156: if n/c goto 07072
07157: delayed rom 11
07160: if n/c goto 07336
07161: delayed rom 2
07162: if n/c goto 07367
07163: jsb 07014
07164: delayed rom 15
07165: if n/c goto 07000
07166: down rotate
07167: if n/c goto 07056
07170: delayed rom 6
07171: jsb 07000
07172: if n/c goto 07150
07173: 0 -> c[w]
07174: c -> addr
07175: data register -> c 0
07176: a exchange c[w]
07177: delayed rom 5
07200: if n/c goto 07212
07201: b exchange c[w]
07202: binary
07203: 0 -> c[w]
07204: p <- 13
07205: load constant 2
07206: load constant 3
07207: b exchange c[w]
07210: p <- 0
07211: if n/c goto 07214
07212: shift right b[m]
07213: a - 1 -> a[p]
07214: if a[p] # 0 then goto 01212
07216: p <- 1
07217: a + 1 -> a[p]
07220: if n/c goto 07244
07221: p <- 12
07222: shift right b[wp]
07223: p - 1 -> p
07224: if b[p] = 0 then goto 01223
07226: shift right a[wp]
07227: a exchange c[w]
07230: load constant 7
07231: a exchange c[w]
07232: p <- 12
07233: if b[p] = 0 then goto 01236
07235: return
07236: a + 1 -> a[p]
07237: if n/c goto 07241
07240: a + 1 -> a[p]
07241: a - 1 -> a[p]
07242: p - 1 -> p
07243: if n/c goto 07233
07244: a - 1 -> a[p]
07245: p <- 4
07246: shift left a[wp]
07247: b exchange c[w]
07250: load constant 2
07251: b exchange c[w]
07252: if n/c goto 07221
07253: p <- 0
07254: if a[p] # 0 then goto 01304
07256: a - 1 -> a[p]
07257: jsb 07310
07260: c - 1 -> c[p]
07261: b exchange c[w]
07262: p <- 1
07263: load constant 2
07264: c -> addr
07265: data register -> c 15
07266: a exchange b[p]
07267: p - 1 -> p
07270: 0 -> s 3
07271: ???1320
07272: if 1 = s 3 then goto 01303
07274: if p # 4 then goto 01267
07276: p <- 0
07277: a + 1 -> a[p]
07300: if n/c goto 07267
07301: p <- 0
07302: a exchange b[p]
07303: return
07304: 0 -> a[p]
07305: jsb 07310
07306: c + 1 -> c[p]
07307: if n/c goto 07261
07310: p <- 13
07311: p - 1 -> p
07312: if b[p] = 0 then goto 01311
07314: b -> c[w]
07315: return
07316: p <- 2
07317: display off
07320: p + 1 -> p
07321: 0 -> s 3
07322: ???1220
07323: if 1 = s 3 then goto 01346
07325: c + 1 -> c[s]
07326: if n/c goto 07321
07327: if p # 2 then goto 01320
07331: ???1220
07332: if 1 = s 3 then goto 01346
07334: ???1120
07335: if 1 = s 3 then goto 01340
07337: if n/c goto 07320
07340: if 0 = s 8 then goto 01344
07342: if 0 = s 10 then goto 01346
07344: delayed rom 5
07345: if n/c goto 07232
07346: p <- 13
07347: 0 -> s 3
07350: load constant 15
07351: return
07352: decimal
07353: p <- 1
07354: 0 - c - 1 -> c[xs]
07355: c - 1 -> c[xs]
07356: c -> a[xs]
07357: if c[p] = 0 then goto 01762
07361: c - 1 -> c[p]
07362: if c[p] = 0 then goto 01367
07364: c + c -> c[p]
07365: if n/c goto 07375
07366: load constant 1
07367: p <- 2
07370: load constant 8
07371: binary
07372: a + c -> a[xs]
07373: delayed rom 15
07374: if n/c goto 07362
07375: load constant 1
07376: if n/c goto 07373
07377: nop
07400: if 1 = s 12 then goto 01417
07402: if 0 = s 9 then goto 01405
07404: c -> stack
07405: 1 -> s 9
07406: 0 -> c[w]
07407: binary
07410: c - 1 -> c[w]
07411: 0 -> c[s]
07412: f exch a
07413: 0 -> a[x]
07414: f exch a
07415: 1 -> s 12
07416: if n/c goto 07422
07417: jsb 07542
07420: if 1 = s 4 then goto 01510
07422: p <- 1
07423: c + 1 -> c[p]
07424: if n/c goto 07451
07425: shift left a[w]
07426: p + 1 -> p
07427: if p # 13 then goto 01423
07431: p - 1 -> p
07432: a exchange c[wp]
07433: p - 1 -> p
07434: c -> a[w]
07435: c - 1 -> c[wp]
07436: a exchange c[x]
07437: if a[m] # 0 then goto 01465
07441: a exchange c[ms]
07442: b exchange c[w]
07443: b -> c[w]
07444: jsb 07603
07445: b -> c[w]
07446: jsb 07747
07447: delayed rom 0
07450: if n/c goto 07463
07451: c - 1 -> c[p]
07452: if p # 3 then goto 01457
07454: 1 -> s 7
07455: 0 -> c[x]
07456: if n/c goto 07433
07457: if 1 = s 7 then goto 01431
07461: f exch a
07462: a + 1 -> a[x]
07463: f exch a
07464: if n/c goto 07431
07465: jsb 07467
07466: if n/c goto 07441
07467: a exchange b[x]
07470: decimal
07471: 0 -> a[x]
07472: f -> a
07473: a + c -> c[x]
07474: p <- 12
07475: if c[p] # 0 then goto 01505
07477: c - 1 -> c[x]
07500: p - 1 -> p
07501: if 1 = s 4 then goto 01475
07503: shift left a[m]
07504: if n/c goto 07475
07505: a exchange b[x]
07506: binary
07507: return
07510: p <- 0
07511: a exchange c[p]
07512: c -> a[w]
07513: p <- 2
07514: shift left a[wp]
07515: p <- 3
07516: shift right a[wp]
07517: b -> c[ms]
07520: a exchange c[w]
07521: c -> a[x]
07522: decimal
07523: if c[xs] = 0 then goto 01527
07525: 0 -> c[xs]
07526: 0 - c -> c[x]
07527: jsb 07467
07530: a exchange c[ms]
07531: delayed rom 5
07532: jsb 07436
07533: if p # 13 then goto 01442
07535: 0 -> s 12
07536: 1 -> s 14
07537: b exchange c[w]
07540: b -> c[w]
07541: if n/c goto 07446
07542: p <- 1
07543: binary
07544: load constant 1
07545: c -> addr
07546: data register -> c 14
07547: a exchange c[p]
07550: f exch a
07551: a exchange c[p]
07552: p <- 13
07553: if c[s] = 0 then goto 01601
07555: c - 1 -> c[s]
07556: if c[s] # 0 then goto 01562
07560: 1 -> s 7
07561: if n/c goto 07601
07562: c - 1 -> c[s]
07563: if c[s] # 0 then goto 01567
07565: 1 -> s 4
07566: if n/c goto 07560
07567: decimal
07570: c + 1 -> c[s]
07571: if n/c goto 07575
07572: 1 -> s 4
07573: 1 -> s 7
07574: if n/c goto 07600
07575: c + 1 -> c[s]
07576: if c[s] = 0 then goto 01573
07600: load constant 9
07601: binary
07602: return
07603: if 0 = s 4 then goto 01607
07605: p <- 3
07606: shift left a[wp]
07607: f -> a
07610: binary
07611: if 0 = s 7 then goto 01617
07613: a + 1 -> a[s]
07614: if 0 = s 4 then goto 01617
07616: a + 1 -> a[s]
07617: p <- 1
07620: load constant 1
07621: c -> addr
07622: a exchange c[w]
07623: c -> data register 14
07624: a exchange c[w]
07625: c -> a[s]
07626: return
07627: if 1 = s 12 then goto 01635
07631: 1 -> s 7
07632: p <- 0
07633: 0 -> a[p]
07634: if n/c goto 07402
07635: jsb 07542
07636: 1 -> s 7
07637: a exchange c[w]
07640: b -> c[w]
07641: if 0 = s 4 then goto 01444
07643: p <- 3
07644: shift right a[wp]
07645: if n/c goto 07444
07646: if 1 = s 12 then goto 01671
07650: if 0 = s 9 then goto 01653
07652: c -> stack
07653: 1 -> s 9
07654: 0 -> c[w]
07655: 1 -> s 12
07656: binary
07657: p <- 12
07660: load constant 1
07661: c -> a[w]
07662: a - 1 -> a[wp]
07663: 0 -> a[x]
07664: 1 -> s 7
07665: 1 -> s 4
07666: f exch a
07667: f -> a
07670: if n/c goto 07442
07671: jsb 07542
07672: a exchange c[w]
07673: b -> c[w]
07674: if 1 = s 4 then goto 01446
07676: if c[m] = 0 then goto 01653
07700: f -> a
07701: p <- 0
07702: load constant 8
07703: p <- 0
07704: if a >= c[p] then goto 01444
07706: p <- 3
07707: 0 -> a[wp]
07710: 1 -> s 4
07711: 1 -> s 7
07712: if n/c goto 07444
07713: if 0 = s 12 then goto 01732
07715: jsb 07542
07716: a exchange c[w]
07717: b -> c[w]
07720: decimal
07721: if 1 = s 4 then goto 01741
07723: if c[m] = 0 then goto 01446
07725: 0 - c - 1 -> c[s]
07726: b exchange c[s]
07727: b -> c[s]
07730: c -> a[s]
07731: if n/c goto 07444
07732: if c[m] = 0 then goto 01737
07734: 0 - c - 1 -> c[s]
07735: delayed rom 13
07736: if n/c goto 07721
07737: delayed rom 0
07740: if n/c goto 07461
07741: p <- 3
07742: shift right a[wp]
07743: a exchange c[xs]
07744: 0 - c - 1 -> c[xs]
07745: a exchange c[xs]
07746: if n/c goto 07520
07747: p <- 1
07750: load constant 2
07751: c -> addr
07752: b -> c[w]
07753: c -> data register 15
07754: return
07755: m2 exch c
07756: if 1 = s 1 then goto 01106
07760: delayed rom 0
07761: if n/c goto 07461
07762: shift right a[x]
07763: shift right a[x]
07764: p <- 1
07765: c -> a[p]
07766: shift left a[x]
07767: 0 -> c[x]
07770: 0 -> s 3
07771: 0 -> s 13
07772: binary
07773: delayed rom 1
07774: a -> rom address
07775: nop
07776: nop
07777: nop