Changed the license to the AGPL3. Downcased all the lisp sources. Completed the READM...
[com-informatimago:com-informatimago.git] / small-cl-pgms / example-soft-opcodes.lisp
1 ;;;; -*- mode:lisp;coding:utf-8 -*-
2 ;;;;**************************************************************************
3 ;;;;FILE:               example-soft-opcodes.lisp
4 ;;;;LANGUAGE:           Common-Lisp
5 ;;;;SYSTEM:             Common-Lisp
6 ;;;;USER-INTERFACE:     NONE
7 ;;;;DESCRIPTION
8 ;;;;    
9 ;;;;    Example of a processor with illegal instruction traps allowing
10 ;;;;    one to implement missing instructions in software.
11 ;;;;    
12 ;;;;AUTHORS
13 ;;;;    <PJB> Pascal J. Bourguignon <pjb@informatimago.com>
14 ;;;;MODIFICATIONS
15 ;;;;    2011-01-08 <PJB> Created.
16 ;;;;BUGS
17 ;;;;LEGAL
18 ;;;;    AGPL3
19 ;;;;    
20 ;;;;    Copyright Pascal J. Bourguignon 2011 - 2011
21 ;;;;    
22 ;;;;    This program is free software: you can redistribute it and/or modify
23 ;;;;    it under the terms of the GNU Affero General Public License as published by
24 ;;;;    the Free Software Foundation, either version 3 of the License, or
25 ;;;;    (at your option) any later version.
26 ;;;;    
27 ;;;;    This program is distributed in the hope that it will be useful,
28 ;;;;    but WITHOUT ANY WARRANTY; without even the implied warranty of
29 ;;;;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30 ;;;;    GNU Affero General Public License for more details.
31 ;;;;    
32 ;;;;    You should have received a copy of the GNU Affero General Public License
33 ;;;;    along with this program.  If not, see <http://www.gnu.org/licenses/>.
34 ;;;;**************************************************************************
35
36
37 ;;; First we define the processor (as a virtual machine here, but the
38 ;;; same could be done in real hardware).
39
40 (deftype word () '(unsigned-byte 64))
41
42 (defparameter *memory-size* 65536 "Number of words in the memory") 
43
44 (defstruct machine 
45   (pc          0 :type word)
46   (accumulator 0 :type word)
47   (memory (make-array *memory-size* :element-type 'word :initial-element 0)))
48
49 (defun opcode (word)  (ldb (byte  8 56) word))
50 (defun src    (word)  (ldb (byte 28 28) word))
51 (defun dst    (word)  (ldb (byte 28  0) word))
52
53 (defconstant +word-mask+ #xffffffffffffffff)
54 (defconstant +save-address+             1)
55 (defconstant +illegal-instruction-trap+ 2)
56 (defconstant +invalid-address-trap+     3)
57
58
59
60 (defun valid-address-p (address)
61   (and (<= 0 address) (< address *memory-size*)))
62
63 (defun word (value) (logand value +word-mask+))
64
65 (defun load-machine (machine address words)
66   "Loads a code vector WORDS in the MACHINE memory at the given ADDRESS."
67   (replace (machine-memory machine) words :start1 address)
68   machine)
69
70 (defun dump-machine (machine address length)
71   "Dumps the MACHINE memory starting from ADDRESS, for LENGTH words."
72   (loop
73      :repeat length
74      :for a :from address
75      :do (format t "~4,'0X: ~16,'0X  ~:*~D~%"
76                  a (aref (machine-memory machine) a)))
77   machine)
78
79 (defun run (machine &key (verbose nil) (step nil))
80   "Run the machine.
81 When verbose is true, prints the instructions and traps executed.
82 When step is true, executes only one step."
83   (loop :named :machine :do
84      (let ((pc (machine-pc machine)))
85        (if (valid-address-p pc)
86            (let* ((instruction (aref (machine-memory machine) pc))
87                   (opcode (opcode instruction))
88                   (src    (src    instruction))
89                   (dst    (dst    instruction)))
90              (flet ((trap (machine trap-address)
91                       (when verbose
92                         (format t "~4,'0X: ~A trap~%" (machine-pc machine)
93                                 (ecase trap-address
94                                   (#.+illegal-instruction-trap+ "Illegal instruction")
95                                   (#.+invalid-address-trap+     "Invalid address"))))
96                       (shiftf (aref (machine-memory machine) +save-address+)
97                               (machine-pc machine)
98                               (aref (machine-memory machine) trap-address))))
99                #+emacs (progn
100                          (cl-indent 'src-instruction 1)
101                          (cl-indent 'dst-instruction 1)
102                          (cl-indent 'acc-instruction 1)
103                          (cl-indent 'jmp-instruction 1))
104                (macrolet ((src-instruction (instruction-form &body body)
105                             `(cond
106                                ((and verbose (format t "~4,'0X: ~S~%" pc ,instruction-form)))
107                                ((not (valid-address-p src))
108                                 (trap machine +invalid-address-trap+))
109                                ((not (zerop dst))
110                                 (trap machine +invalid-address-trap+))
111                                (t
112                                 ,@body
113                                 (incf (machine-pc machine)))))
114                           (dst-instruction (instruction-form &body body)
115                             `(cond
116                                ((and verbose (format t "~4,'0X: ~S~%" pc ,instruction-form)))
117                                ((not (zerop src))
118                                 (trap machine +invalid-address-trap+))
119                                ((not (valid-address-p dst))
120                                 (trap machine +invalid-address-trap+))
121                                (t
122                                 ,@body
123                                 (incf (machine-pc machine)))))
124                           (acc-instruction (instruction-form &body body)
125                             `(cond
126                                ((and verbose (format t "~4,'0X: ~S~%" pc ,instruction-form)))
127                                ((not (zerop src))
128                                 (trap machine +invalid-address-trap+))
129                                ((not (zerop dst))
130                                 (trap machine +invalid-address-trap+))
131                                (t
132                                 ,@body
133                                 (incf (machine-pc machine)))))
134                           (jmp-instruction (instruction-form &body body)
135                             `(cond
136                                ((and verbose (format t "~4,'0X: ~S~%" pc ,instruction-form)))
137                                ((not (valid-address-p src))
138                                 (trap machine +invalid-address-trap+))
139                                ((not (zerop dst))
140                                 (trap machine +invalid-address-trap+))
141                                (t
142                                 ,@body))))
143                  (if (zerop (ldb (byte 4 0) opcode))
144                      (case (ldb (byte 4 4) opcode)
145                        ;; Notice not all instructions are implemented:
146                        ;; 0000 move src,dst
147                        ;; 0001 load src,acc
148                        (#b0001
149                         (src-instruction `(load ,src acc)
150                           (setf (machine-accumulator machine)
151                                 (aref (machine-memory machine) src))))
152                        ;; 0010 store acc,dst
153                        (#b0010
154                         (dst-instruction `(store acc ,dst)
155                           (setf (aref (machine-memory machine) dst)
156                                 (machine-accumulator machine))))
157                        ;; 0100 add src,acc
158                        (#b0100
159                         (src-instruction `(add ,src acc)
160                           (setf (machine-accumulator machine)
161                                 (word (+ (machine-accumulator machine)
162                                          (aref (machine-memory machine) src))))))
163                        ;; 0101 sub src,acc
164                        ;; 0110 mul src,acc
165                        ;; 0111 div src,acc
166                        ;; 1000 not acc
167                        (#b1000
168                         (acc-instruction `(not acc)
169                           (setf (machine-accumulator machine)
170                                 (word (lognot (machine-accumulator machine))))))
171                        ;; 1001 neg acc
172                        ;; (#b10100000 (lshift src acc))
173                        (#b1010
174                         (src-instruction `(lshift ,src acc)
175                           (setf (machine-accumulator machine)
176                                 (word (ash (machine-accumulator machine)
177                                            (aref (machine-memory machine) src))))))
178                        ;; (#b10110000 (rshift src acc))
179                        (#b1011
180                         (src-instruction `(rshift ,src acc)
181                           (setf (machine-accumulator machine)
182                                 (word (ash (machine-accumulator machine)
183                                            (- (aref (machine-memory machine) src)))))))
184                        ;; (#b11000000 (and src acc))
185                        (#b1100
186                         (src-instruction `(and ,src acc)
187                           (setf (machine-accumulator machine)
188                                 (word (logand (machine-accumulator machine)
189                                               (aref (machine-memory machine) src))))))
190                        ;; (#b11010000 (or  src acc))
191                        (#b1101
192                         (src-instruction `(or ,src acc)
193                           (setf (machine-accumulator machine)
194                                 (word (logior (machine-accumulator machine)
195                                               (aref (machine-memory machine) src))))))
196                        ;; 1110 jzero src
197                        (#b1110
198                         (jmp-instruction `(jzero ,src)
199                           (if (zerop (machine-accumulator machine))
200                               (setf (machine-pc machine) src)
201                               (incf (machine-pc machine)))))
202                        ;; 1111 jump  src
203                        (#b1111
204                         (jmp-instruction `(jump ,src)
205                           (setf (machine-pc machine) src)))
206                        (otherwise
207                         (trap machine +illegal-instruction-trap+)))
208                      (case opcode
209                        (#b11111111
210                         (jmp-instruction `(halt)
211                           (return-from :machine)))
212                        (otherwise
213                         (trap machine +illegal-instruction-trap+)))))))
214            (trap machine +invalid-address-trap+)))
215      :until step))
216
217
218 ;;; Next we write a little LAP assembler.
219 ;;; Notice we may assemble instructions that are not implemented (yet)
220 ;;; in hardware.
221
222 (defparameter *instructions*
223   '((#b00000000 (move src dst))
224     (#b00010000 (load src acc))
225     (#b00100000 (store acc dst))
226     (#b01000000 (add src acc))
227     (#b01010000 (sub src acc))
228     (#b01100000 (mul src acc))
229     (#b01110000 (div src acc))
230     (#b10000000 (not acc))
231     (#b10010000 (neg acc))
232     (#b10100000 (lshift src acc))
233     (#b10110000 (rshift src acc))
234     (#b11000000 (and src acc))
235     (#b11010000 (or  src acc))
236     (#b11100000 (jzero src))
237     (#b11110000 (jump src))
238     (#b11111111 (halt))))
239
240
241 (defun encode-instruction (op src dst)
242   (word (dpb op (byte 8 56) (dpb src (byte 28 28) dst))))
243
244 (defun sym-eval (expression bindings)
245   (progv
246       (mapcar (function car) bindings)
247       (mapcar (function cdr) bindings)
248     (eval expression)))
249
250 (defun validate-operand (pattern operand symtable)
251   (word
252    (ecase pattern
253      ((nil)
254       (if (null operand)
255           0
256           (error "Expected no operand, got ~S in" operand)))
257      ((acc)
258       (if (eql operand 'acc)
259           0
260           (error "Expected ACC, got ~S in" operand)))
261      ((src dst)
262       (sym-eval operand symtable)))))
263
264 (defun assemble (address lap)
265   "
266 ADDRESS is the base address of the code.
267 There's no operator to change the current address in a LAP list.
268
269 LAP is a list of symbols or LAP sexps.  Symbols are equaled to the
270 current address and entered in the symbol table during the first
271 phase.  LAP sexps may be either one of the instructions defined in
272 *INSTRUCTIONS*, or one of the two special operator defined below.
273
274 In addition to the instruction opcodes, there is:
275     (eql symbol expr)
276 to enter a symbol in the symbol table. expr is evaluated right away.
277
278 And:
279     (dcl expr ...)
280 to store arbitrary values in memory. * is the address of the first one.
281
282 The SRC, DST, and EXPR forms are evaluated in Lisp, in a context where
283 the symbols in the assembler symbol table are dynamically bound to
284 their value, with PROGV and EVAL.  Any lisp expression may be used
285 here, executed during the first phase for EQL, and the second phase
286 for the other LAP forms.
287
288 Return the code vector, and the symbol table,
289 an a-list of (symbol . values).
290 "
291   (loop
292      :with symtable ; a-list symbol -> address
293      = (loop
294           :named first-phase
295           :with symtable = '()
296           :with address = address
297           :for statement :in lap
298           :if (atom statement) :do (push (cons statement address) symtable)
299           :else :do (case (first statement)
300                       ((eql)
301                        (unless (symbolp (second statement))
302                          (error "EQL requires a symbol as first argument instead of ~S"
303                                 (second statement)))
304                        (push (cons (second statement)
305                                    (sym-eval (third statement)
306                                              (acons '* address symtable)))
307                              symtable))
308                       ((dcl) (incf address (length (rest statement))))
309                       (otherwise (incf address)))
310           :finally (return-from first-phase symtable))
311      :with address = address
312      :with code = '()
313      :for statement :in lap
314      :do (when (listp statement)
315            (let* ((op (first statement))
316                   (instruction (find op *instructions* :key (function caadr))))
317              (handler-case
318                  (cond
319                    ((eql op 'eql))
320                    ((eql op 'dcl)
321                     (let ((symtable  (acons '* address symtable)))
322                       (dolist (expr (rest statement))
323                         (push (sym-eval expr symtable) code))
324                       (incf address (length (rest statement)))))
325                    (instruction
326                     (push
327                      (encode-instruction
328                       (first instruction)
329                       (validate-operand (second (second instruction)) (second statement)
330                                         (acons '* address symtable))
331                       (validate-operand (third  (second instruction)) (third  statement)
332                                         (acons '* address symtable)))
333                      code)
334                     (incf address))
335                    (t
336                     (error "Invalid opcode in lap statement")))
337                (error (err)
338                  (error "~A in ~A: ~S" err address statement)))))
339      :finally (return (values (coerce (nreverse code) 'vector)
340                               symtable))))
341
342
343 ;;; Finally, we can write a few missing instructions in assembler,
344 ;;; load them in the machine, and write a program using them.
345 ;;;
346 ;;; In real machines, these handlers are usually priviledged code, but
347 ;;; nothing prevents a system to let application define their own
348 ;;; opcodes too.
349
350
351 (defvar *machine* nil
352   "for debugging purpose, we bind the last machine used here.")
353
354 (multiple-value-bind (code symtable)
355     (assemble
356      0
357      '(
358        ;; Address 0 contains a jump to start, the machine boots with pc=0
359        (jump start)
360
361        ;; Address 1 is where the PC of the instruction that is invalid
362        ;; or accessed an invalid address is stored.
363        return-pc           (dcl 0)
364
365        ;; Address 2 is where the address of the illegal instruction
366        ;; trap handler is stored.
367        illegal-instruction (dcl process-illegal-instruction)
368
369        ;; Address 3 is where the address of the invalid address
370        ;; trap handler is stored.
371        invalid-address     (dcl process-invalid-address)
372
373        ;; Let's start with the illegal instruction handler:
374        process-illegal-instruction
375        
376        (store acc save-acc)                ; save accumulator.
377        ;; We really would need a stack and indirect addressing...
378        ;; but this is to show that it's possible to start with a very
379        ;; crude machine, and we may add higher level instructions first
380        ;; in software.
381                                         ; save the return address
382        (load return-pc acc)                ; get the instruction address
383        (add one acc)                       ; add one for return address
384        (lshift src-offset acc)    ; store it into the return instruction.
385        (add return-op acc)
386        (store acc return-instruction)
387        
388        (load return-pc acc)          ; get the instruction address
389        (lshift src-offset acc)       ; store it into the load instruction
390        (add load-op acc)
391        (store acc load-instruction)
392        
393        load-instruction (load 0 acc)       ; get the instruction
394        (store acc instruction)
395        (and opcode-lo-mask acc)
396        (jzero lo-ok)
397        (jump really-illegal-instruction)
398
399        lo-ok
400        (load instruction acc)
401        (and opcode-hi-mask acc)
402        (rshift opcode-hi-offset acc)
403        (not acc)               ; remember, we don't have NEG nor SUB yet.
404        (add one acc)           ; so we get two-complement of opcode
405        (store acc -op-hi)
406
407        (load -op-hi acc)
408        (add move-op acc)
409        (jzero move)
410
411        (load -op-hi acc)
412        (add sub-op acc)
413        (jzero sub)
414
415        (load -op-hi acc)
416        (add neg-op acc)
417        (jzero neg)
418
419        (load -op-hi acc)
420        (add or-op acc)
421        (jzero or)
422
423        move-op (dcl #b0000)
424        sub-op  (dcl #b0101)
425        mul-op  (dcl #b0110)
426        div-op  (dcl #b0111)
427        neg-op  (dcl #b1001)
428        or-op   (dcl #b1101)
429        
430        -op-hi           (dcl 0)
431        opcode-hi-mask   (dcl #xf000000000000000)
432        opcode-hi-offset (dcl 60)
433        opcode-lo-mask   (dcl #x0f00000000000000)
434
435
436        ;; Not implemented yet, we'd need an OS to do something with those.
437        really-illegal-instruction (halt)
438        process-invalid-address    (halt)
439        ;; eg. process-invalid-address could go to a VM manager.
440        
441        neg
442        (load save-acc acc)
443        (not acc)
444        (add one acc)
445        (store acc save-acc)
446        (jump return)
447        
448
449        sub
450        (load instruction acc)              ; load the src data
451        (and src-mask acc)                  ; maskout the source address
452        (add load-op acc)
453        (store acc sub-load-data-instruction)
454        sub-load-data-instruction (load 0 acc)
455        (not acc)
456        (add one acc)
457        (add save-acc acc)
458        (store acc save-acc)
459        (jump return)
460        
461        or                ; implemented as (not (and (not mem) (not acc)))
462        (load instruction acc)              ; load the src data
463        (and src-mask acc)                  ; maskout the source address
464        (add load-op acc)
465        (store acc or-load-data-instruction)
466        or-load-data-instruction (load 0 acc)
467        (not acc)
468        (store acc or-op)
469        (load save-acc acc)
470        (not acc)
471        (and or-op acc)
472        (not acc)
473        (store acc save-acc)
474        (jump return)
475        or-op (dcl 0)
476        
477        move                                ; move src dst
478        (load instruction acc)              ; load the src data:
479        (and src-mask acc)                  ; maskout the source address
480        (add load-op acc)
481        (store acc move-load-data-instruction)
482        move-load-data-instruction (load 0 acc)
483        (store acc data)
484        (load instruction acc)              ; store the data into the dst
485        (and dst-mask acc)
486        (add store-op acc)
487        (store acc store-data-instruction)
488        (load data acc)
489        store-data-instruction (store acc 0)
490
491        return   
492        (load save-acc acc)                 ; restore the accumulator:
493        return-instruction (jump 0)         ; and continue
494
495        return-op   (jump 0)
496        load-op     (load 0 acc)
497        store-op    (store acc 0)
498        
499        src-offset  (dcl 28)
500        src-mask*   (dcl #xff0000000fffffff)
501        src-mask    (dcl #x00fffffff0000000)
502        dst-mask    (dcl #x000000000fffffff)
503        one         (dcl 1)
504        save-acc    (dcl 0)
505        instruction (dcl 0)
506        data        (dcl 0)
507
508
509        start ; let's test the new opcodes:
510
511        (move src dst)
512        (move (+ src 1) (+ dst 1))
513        (move (+ src 2) (+ dst 2))
514        (move (+ src 3) (+ dst 3))
515
516        (load pi acc)
517        (neg acc)
518        (store acc -pi)
519
520        (load a acc)
521        (or b acc)
522        (store acc a-or-b)
523
524        (load pi acc)
525        (sub pi-1 acc)
526        (store acc pi-diff)
527
528        (halt)
529
530        ;; We will dump the memory from src to end when the machine
531        ;; halts:
532        
533        src     (dcl #x1122334455667788 #xff #xdeadbeef #xfeedbabe)
534        dst     (dcl 0 0 0 0)
535        pi      (dcl 3141592653589)
536        pi-1    (dcl 2141592653589)
537        pi-diff (dcl 1000000000000)
538        -pi     (dcl 0)
539        a       (dcl #xffffffff00000000)
540        b       (dcl #xffff0000ffff0000)
541        a-or-b  (dcl 0)
542        end     (dcl 0)
543
544        ))
545   (let ((start (cdr (assoc 'src symtable)))
546         (end   (cdr (assoc 'end symtable)))
547         (machine (make-machine)))
548     (print code) (terpri) (finish-output)
549     (setf *machine* machine)
550     (load-machine machine 0 code)
551     (let ((*print-length* 10)) (print machine)) (terpri) (finish-output)
552     (run machine :verbose t)
553     (dump-machine machine start (- end start))))
554
555
556 #||
557 0000: (JUMP 103)
558 0067: Illegal instruction trap
559 0004: (STORE ACC 100)
560 0005: (LOAD 1 ACC)
561 0006: (ADD 99 ACC)
562 0007: (LSHIFT 95 ACC)
563 0008: (ADD 92 ACC)
564 0009: (STORE ACC 91)
565 000A: (LOAD 1 ACC)
566 000B: (LSHIFT 95 ACC)
567 000C: (ADD 93 ACC)
568 000D: (STORE ACC 14)
569 000E: (LOAD 103 ACC)
570 000F: (STORE ACC 101)
571 0010: (AND 46 ACC)
572 0011: (JZERO 19)
573 0013: (LOAD 101 ACC)
574 0014: (AND 44 ACC)
575 0015: (RSHIFT 45 ACC)
576 0016: (NOT ACC)
577 0017: (ADD 99 ACC)
578 0018: (STORE ACC 43)
579 0019: (LOAD 43 ACC)
580 001A: (ADD 37 ACC)
581 001B: (JZERO 78)
582 004E: (LOAD 101 ACC)
583 004F: (AND 97 ACC)
584 0050: (ADD 93 ACC)
585 0051: (STORE ACC 82)
586 0052: (LOAD 117 ACC)
587 0053: (STORE ACC 102)
588 0054: (LOAD 101 ACC)
589 0055: (AND 98 ACC)
590 0056: (ADD 94 ACC)
591 0057: (STORE ACC 89)
592 0058: (LOAD 102 ACC)
593 0059: (STORE ACC 121)
594 005A: (LOAD 100 ACC)
595 005B: (JUMP 104)
596 0068: Illegal instruction trap
597 0004: (STORE ACC 100)
598 0005: (LOAD 1 ACC)
599 0006: (ADD 99 ACC)
600 0007: (LSHIFT 95 ACC)
601 0008: (ADD 92 ACC)
602 0009: (STORE ACC 91)
603 000A: (LOAD 1 ACC)
604 000B: (LSHIFT 95 ACC)
605 000C: (ADD 93 ACC)
606 000D: (STORE ACC 14)
607 000E: (LOAD 104 ACC)
608 000F: (STORE ACC 101)
609 0010: (AND 46 ACC)
610 0011: (JZERO 19)
611 0013: (LOAD 101 ACC)
612 0014: (AND 44 ACC)
613 0015: (RSHIFT 45 ACC)
614 0016: (NOT ACC)
615 0017: (ADD 99 ACC)
616 0018: (STORE ACC 43)
617 0019: (LOAD 43 ACC)
618 001A: (ADD 37 ACC)
619 001B: (JZERO 78)
620 004E: (LOAD 101 ACC)
621 004F: (AND 97 ACC)
622 0050: (ADD 93 ACC)
623 0051: (STORE ACC 82)
624 0052: (LOAD 118 ACC)
625 0053: (STORE ACC 102)
626 0054: (LOAD 101 ACC)
627 0055: (AND 98 ACC)
628 0056: (ADD 94 ACC)
629 0057: (STORE ACC 89)
630 0058: (LOAD 102 ACC)
631 0059: (STORE ACC 122)
632 005A: (LOAD 100 ACC)
633 005B: (JUMP 105)
634 0069: Illegal instruction trap
635 0004: (STORE ACC 100)
636 0005: (LOAD 1 ACC)
637 0006: (ADD 99 ACC)
638 0007: (LSHIFT 95 ACC)
639 0008: (ADD 92 ACC)
640 0009: (STORE ACC 91)
641 000A: (LOAD 1 ACC)
642 000B: (LSHIFT 95 ACC)
643 000C: (ADD 93 ACC)
644 000D: (STORE ACC 14)
645 000E: (LOAD 105 ACC)
646 000F: (STORE ACC 101)
647 0010: (AND 46 ACC)
648 0011: (JZERO 19)
649 0013: (LOAD 101 ACC)
650 0014: (AND 44 ACC)
651 0015: (RSHIFT 45 ACC)
652 0016: (NOT ACC)
653 0017: (ADD 99 ACC)
654 0018: (STORE ACC 43)
655 0019: (LOAD 43 ACC)
656 001A: (ADD 37 ACC)
657 001B: (JZERO 78)
658 004E: (LOAD 101 ACC)
659 004F: (AND 97 ACC)
660 0050: (ADD 93 ACC)
661 0051: (STORE ACC 82)
662 0052: (LOAD 119 ACC)
663 0053: (STORE ACC 102)
664 0054: (LOAD 101 ACC)
665 0055: (AND 98 ACC)
666 0056: (ADD 94 ACC)
667 0057: (STORE ACC 89)
668 0058: (LOAD 102 ACC)
669 0059: (STORE ACC 123)
670 005A: (LOAD 100 ACC)
671 005B: (JUMP 106)
672 006A: Illegal instruction trap
673 0004: (STORE ACC 100)
674 0005: (LOAD 1 ACC)
675 0006: (ADD 99 ACC)
676 0007: (LSHIFT 95 ACC)
677 0008: (ADD 92 ACC)
678 0009: (STORE ACC 91)
679 000A: (LOAD 1 ACC)
680 000B: (LSHIFT 95 ACC)
681 000C: (ADD 93 ACC)
682 000D: (STORE ACC 14)
683 000E: (LOAD 106 ACC)
684 000F: (STORE ACC 101)
685 0010: (AND 46 ACC)
686 0011: (JZERO 19)
687 0013: (LOAD 101 ACC)
688 0014: (AND 44 ACC)
689 0015: (RSHIFT 45 ACC)
690 0016: (NOT ACC)
691 0017: (ADD 99 ACC)
692 0018: (STORE ACC 43)
693 0019: (LOAD 43 ACC)
694 001A: (ADD 37 ACC)
695 001B: (JZERO 78)
696 004E: (LOAD 101 ACC)
697 004F: (AND 97 ACC)
698 0050: (ADD 93 ACC)
699 0051: (STORE ACC 82)
700 0052: (LOAD 120 ACC)
701 0053: (STORE ACC 102)
702 0054: (LOAD 101 ACC)
703 0055: (AND 98 ACC)
704 0056: (ADD 94 ACC)
705 0057: (STORE ACC 89)
706 0058: (LOAD 102 ACC)
707 0059: (STORE ACC 124)
708 005A: (LOAD 100 ACC)
709 005B: (JUMP 107)
710 006B: (LOAD 125 ACC)
711 006C: Illegal instruction trap
712 0004: (STORE ACC 100)
713 0005: (LOAD 1 ACC)
714 0006: (ADD 99 ACC)
715 0007: (LSHIFT 95 ACC)
716 0008: (ADD 92 ACC)
717 0009: (STORE ACC 91)
718 000A: (LOAD 1 ACC)
719 000B: (LSHIFT 95 ACC)
720 000C: (ADD 93 ACC)
721 000D: (STORE ACC 14)
722 000E: (LOAD 108 ACC)
723 000F: (STORE ACC 101)
724 0010: (AND 46 ACC)
725 0011: (JZERO 19)
726 0013: (LOAD 101 ACC)
727 0014: (AND 44 ACC)
728 0015: (RSHIFT 45 ACC)
729 0016: (NOT ACC)
730 0017: (ADD 99 ACC)
731 0018: (STORE ACC 43)
732 0019: (LOAD 43 ACC)
733 001A: (ADD 37 ACC)
734 001B: (JZERO 78)
735 001C: (LOAD 43 ACC)
736 001D: (ADD 38 ACC)
737 001E: (JZERO 54)
738 001F: (LOAD 43 ACC)
739 0020: (ADD 41 ACC)
740 0021: (JZERO 49)
741 0031: (LOAD 100 ACC)
742 0032: (NOT ACC)
743 0033: (ADD 99 ACC)
744 0034: (STORE ACC 100)
745 0035: (JUMP 90)
746 005A: (LOAD 100 ACC)
747 005B: (JUMP 109)
748 006D: (STORE ACC 128)
749 006E: (LOAD 129 ACC)
750 006F: (OR 130 ACC)
751 0070: (STORE ACC 131)
752 0071: (LOAD 125 ACC)
753 0072: Illegal instruction trap
754 0004: (STORE ACC 100)
755 0005: (LOAD 1 ACC)
756 0006: (ADD 99 ACC)
757 0007: (LSHIFT 95 ACC)
758 0008: (ADD 92 ACC)
759 0009: (STORE ACC 91)
760 000A: (LOAD 1 ACC)
761 000B: (LSHIFT 95 ACC)
762 000C: (ADD 93 ACC)
763 000D: (STORE ACC 14)
764 000E: (LOAD 114 ACC)
765 000F: (STORE ACC 101)
766 0010: (AND 46 ACC)
767 0011: (JZERO 19)
768 0013: (LOAD 101 ACC)
769 0014: (AND 44 ACC)
770 0015: (RSHIFT 45 ACC)
771 0016: (NOT ACC)
772 0017: (ADD 99 ACC)
773 0018: (STORE ACC 43)
774 0019: (LOAD 43 ACC)
775 001A: (ADD 37 ACC)
776 001B: (JZERO 78)
777 001C: (LOAD 43 ACC)
778 001D: (ADD 38 ACC)
779 001E: (JZERO 54)
780 0036: (LOAD 101 ACC)
781 0037: (AND 97 ACC)
782 0038: (ADD 93 ACC)
783 0039: (STORE ACC 58)
784 003A: (LOAD 126 ACC)
785 003B: (NOT ACC)
786 003C: (ADD 99 ACC)
787 003D: (ADD 100 ACC)
788 003E: (STORE ACC 100)
789 003F: (JUMP 90)
790 005A: (LOAD 100 ACC)
791 005B: (JUMP 115)
792 0073: (STORE ACC 127)
793 0074: (HALT)
794 0075: 1122334455667788  1234605616436508552
795 0076: 00000000000000FF  255
796 0077: 00000000DEADBEEF  3735928559
797 0078: 00000000FEEDBABE  4276992702
798 0079: 1122334455667788  1234605616436508552
799 007A: 00000000000000FF  255
800 007B: 00000000DEADBEEF  3735928559
801 007C: 00000000FEEDBABE  4276992702
802 007D: 000002DB75839F15  3141592653589
803 007E: 000001F2A0DE8F15  2141592653589
804 007F: 000000E8D4A51000  1000000000000
805 0080: FFFFFD248A7C60EB  18446740932116898027
806 0081: FFFFFFFF00000000  18446744069414584320
807 0082: FFFF0000FFFF0000  18446462603027742720
808 0083: FFFFFFFFFFFF0000  18446744073709486080
809
810 ||#