Skip to content

Instantly share code, notes, and snippets.

@jakiki6

jakiki6/lazarus.tex

Created April 22, 2023 20:51
Show Gist options
  • Save jakiki6/95725d55163dcfca2002af1304df1363 to your computer and use it in GitHub Desktop.
Save jakiki6/95725d55163dcfca2002af1304df1363 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
lazarus.tex
\documentclass{article}
\usepackage{geometry}
\usepackage{listings}
\geometry{letterpaper, margin=1in}
\raggedright
\begin{document}
\tableofcontents
\pagebreak
\section{Interpreter}
You can run the code by applying the following algorithm:
\begin{enumerate}
\item let there be 2 functions: getchar to read an ascii character and putchar to write one
\item let there be 5 unsigned registers with a width of 16 bits: A, B, C, R and PC
\item let there be an array M that holds unsigned 16 bit values and has a size of 65536 items or less
\item fill M with the data from the binary section
\item A := M[PC]
\item PC := PC + 1
\item B := M[PC]
\item PC := PC + 1
\item C := M[PC]
\item PC := PC + 1
\item if A is equal to 65535: M[B] := getchar()
\item if not and B is equal to 65535: putchar(M[A])
\item if both cases do not apply: R := M[B] - M[A]; M[B] = R; if R is bigger than 32768 or R is equal to 0: PC := C
\item if PC is less than 32768: go to 5
\end{enumerate}
\pagebreak
\section{Source code}
In order to bootstrap the system itself, you need to feed the following code to it:
\begin{lstlisting}
defined eforth [if] ' ) <ok> ! [then] ( Turn off ok prompt )
\ Project: Cross Compiler / eForth interpreter for a SUBLEQ CPU
\ License: The Unlicense
\ Author: Richard James Howe
\ Email: howe.r.j.89@gmail.com
\ Repo: <https://github.com/howerj/subleq>
\
\ References:
\
\ - <https://en.wikipedia.org/wiki/Threaded_code>
\ - <https://github.com/howerj/embed>
\ - <https://github.com/howerj/forth-cpu>
\ - <https://github.com/samawati/j1eforth>
\ - <https://www.bradrodriguez.com/papers/>
\ - 8086 eForth 1.0 by Bill Muench and C. H. Ting, 1990
\ - <https://www.bradrodriguez.com/papers/mtasking.html>,
\ For multitasking support
\ - <https://forth-standard.org/standard/block>,
\ For the block word-set, which is partially implemented.
\
\ The way this cross compiler works is the following:
\
\ 1. An assembler for the SUBLEQ machine is made.
\ 2. A virtual machine is made with that assembler that can
\ support higher level programming constructs, specifically,
\ the easy execution of Forth.
\ 3. Forth word definitions are built up, which are then used
\ to construct a full Forth interpreter.
\ 4. The resulting image is output to standard out.
\
\ Check the references for more detailed examples for other
\ systems. Some keywords that will help are; Forth,
\ Meta-compilation, Cross compiler, eForth, 8086 eForth,
\ JonesForth, j1eforth.
\
\ Notes:
\
\ - If "see", the decompiler, was advanced enough we could
\ dispense with the source code, an interesting concept.
\ - The eForth image could determine the SUBLEQ machine size,
\ and adjust itself accordingly, it would not even require a
\ power-of-two integer width. Another interesting concept would
\ be to adapt this eForth to a SUBLEQ machine that used bignums
\ for each cell, this would require re-engineering functions
\ like bitwise AND/OR/XOR as they require a fixed cell width to
\ work efficiently.
\ - The eForth image could be compressed with LZSS to save on
\ space. If the de-compressor was written in pure SUBLEQ it
\ would compression of most of the image instead of just the
\ eForth section of it.
\ - A website with an interactive simulator is available at:
\ <https://github.com/howerj/subleq-js>
\ - It would be nice to make a 7400 Integrated Circuit board
\ that could run and execute this code, or a project in VHDL
\ for an FPGA that could do it.
\ - The virtual machine could be sped up with optimization
\ magic
\ - Half of the memory used is just for the virtual machine
\ that allows Forth to be written.
\ - The BLOCK word-set does not use mass storage, but maps
\ blocks to memory, if a mass storage peripheral were to be
\ added these functions would have to be modified. It might be
\ nice to make a Forth File System based on blocks as well,
\ then this system could act like a primitive DOS.
\ - Reformatting the text for a 64 byte line width would allow
\ storage in Forth blocks. This file could then perhaps we
\ stored within the image.
\ - Much like my Embed VM project and Forth interpreter,
\ available at \ <https://github.com/howerj/embed>, this file
\ could be documented extensively and explain how to build up
\ a Forth interpreter from scratch.
\
only forth definitions hex
defined (order) 0= [if]
: (order) ( w wid*n n -- wid*n w n )
dup if
1- swap >r recurse over r@ xor
if 1+ r> -rot exit then rdrop
then ;
: -order get-order (order) nip set-order ; ( wid -- )
: +order dup >r -order get-order r> swap 1+ set-order ;
[then]
defined eforth [if]
: wordlist here cell allot 0 over ! ; ( -- wid : alloc wid )
[then]
wordlist constant meta.1 ( meta-compiler word set )
wordlist constant target.1 ( target eForth word set )
wordlist constant assembler.1 ( assembler word set )
wordlist constant target.only.1 ( target only word set )
defined eforth [if] system +order [then]
meta.1 +order definitions
2 constant =cell \ Target cell size
4000 constant size \ Size of image working area
100 constant =buf \ Size of text input buffers in target
100 constant =stksz \ Size of return and variable stacks
FC00 constant =thread \ Initial start of thread area
0008 constant =bksp \ Backspace character value
000A constant =lf \ Line feed character value
000D constant =cr \ Carriage Return character value
007F constant =del \ Delete character
create tflash tflash size cells allot size erase
variable tdp 0 tdp ! ( target dictionary pointer )
variable tlast 0 tlast ! ( last defined target word pointer )
variable tlocal 0 tlocal ! ( local variable allocator )
variable voc-last 0 voc-last ! ( last defined in any vocab )
: :m meta.1 +order definitions : ; ( --, "name" )
: ;m postpone ; ; immediate ( -- )
:m tcell 2 ;m ( -- 2 : bytes in a target cell )
:m there tdp @ ;m ( -- a : target dictionary pointer value )
:m tc! tflash + c! ;m ( c a -- : target write char )
:m tc@ tflash + c@ ;m ( a -- c : target get char )
:m t! over FF and over tc! swap 8 rshift swap 1+ tc! ;m
:m t@ dup tc@ swap 1+ tc@ 8 lshift or ;m ( a -- u : target @ )
:m taligned dup 1 and + ;m ( u -- u : align target pointer )
:m talign there 1 and tdp +! ;m ( -- : align target dic. ptr. )
:m tc, there tc! 1 tdp +! ;m ( c -- : write char to targ. dic.)
:m t, there t! 2 tdp +! ;m ( u -- : write cell to target dic. )
:m tallot tdp +! ;m ( u -- : allocate bytes in target dic. )
:m mdrop drop ;m ( u -- : always call drop )
defined eforth [if]
:m tpack dup tc, for aft count tc, then next drop ;m
:m parse-word bl word ?nul count ;m ( -- a u )
:m limit ;m ( u -- u16 : not needed on 16-bit systems )
[else]
:m tpack talign dup tc, 0 ?do count tc, loop drop ;m
:m limit FFFF and ;m ( u -- u16 : limit variable to 16 bits )
[then]
:m $literal talign [char] " word count tpack talign ;m
defined eforth [if]
:m #dec s>d if [char] - emit then (.) ;m ( n16 -- )
[else]
:m #dec dup 8000 u>= if negate limit -1 >r else 0 >r then
0 <# #s r> sign #> type ;m ( n16 -- )
[then]
0 constant cgen
cgen [if] :m msep 2C emit ;m [else] :m msep A emit ;m [then]
:m mdump taligned ( a u -- )
begin ?dup
while swap dup @ limit #dec msep tcell + swap tcell -
repeat drop ;m
:m save-target decimal tflash there mdump ;m ( -- )
:m .end only forth definitions decimal ;m ( -- )
:m atlast tlast @ ;m ( -- a )
:m local? tlocal @ ;m
:m lallot >r tlocal @ r> + tlocal ! ;m ( u -- allot in target )
:m tuser ( --, "name", Created-Word: -- u )
get-current >r meta.1 set-current create r>
set-current tlocal @ =cell lallot , does> @ ;m
:m tvar get-current >r ( --, "name", Created-Word: -- a )
meta.1 set-current create
r> set-current there , t, does> @ ;m
:m label: get-current >r ( --, "name", Created-Word: -- a )
meta.1 set-current create
r> set-current there , does> @ ;m
:m tdown =cell negate and ;m ( a -- a : align down )
:m tnfa =cell + ;m ( pwd -- nfa : move to name field address )
:m tcfa tnfa dup c@ 1F and + =cell + tdown ;m ( pwd -- cfa )
:m compile-only voc-last @ tnfa t@ 20 or voc-last @ tnfa t! ;m
:m immediate voc-last @ tnfa t@ 40 or voc-last @ tnfa t! ;m
:m half dup 1 and abort" unaligned" 2/ ;m ( a -- a )
:m double 2* ;m ( a -- a )
defined eforth [if]
:m (') bl word find ?found cfa ;m
:m t' (') >body @ ;m ( --, "name" )
:m to' target.only.1 +order (') >body @ target.only.1 -order ;m
[else]
:m t' ' >body @ ;m ( --, "name" )
:m to' target.only.1 +order ' >body @ target.only.1 -order ;m
[then]
:m tcompile to' half t, ;m
:m >tbody =cell + ;m
:m tcksum taligned dup C0DE - FFFF and >r
begin ?dup
while swap dup t@ r> + FFFF and >r =cell + swap =cell -
repeat drop r> ;m ( a u -- u : compute a checksum )
:m mkck dup there swap - tcksum ;m ( -- u : checksum of image )
:m postpone ( --, "name" )
target.only.1 +order t' target.only.1 -order 2/ t, ;m
:m thead talign there tlast @ t, dup tlast ! voc-last !
parse-word talign tpack talign ;m ( --, "name" )
:m header >in @ thead >in ! ;m ( --, "name" )
:m :ht ( "name" -- : forth routine, no header )
get-current >r target.1 set-current create
r> set-current CAFE talign there ,
does> @ 2/ t, ;m
:m :t header :ht ;m ( "name" -- : forth routine )
:m :to ( "name" -- : forth, target only routine )
header
get-current >r
target.only.1 set-current create
r> set-current
CAFE talign there ,
does> @ 2/ t, ;m
:m :a ( "name" -- : assembly routine, no header )
1234 target.1 +order definitions
create talign there , assembler.1 +order does> @ 2/ t, ;m
:m (fall-through); 1234 <>
if abort" unstructured" then assembler.1 -order ;m
:m (a); (fall-through); ;m
defined eforth [if] system -order [then]
:m Z 0 t, ;m ( -- : Address 0 must contain 0 )
:m NADDR there 2/ 1+ t, ;m ( --, jump to next cell )
:m HALT 0 t, 0 t, -1 t, ;m ( --, Halt but do not catch fire )
:m JMP 2/ Z Z t, ;m ( a --, Jump to location )
:m ADD swap 2/ t, Z NADDR Z 2/ t, NADDR Z Z NADDR ;m
:m SUB swap 2/ t, 2/ t, NADDR ;m ( a a -- : subtract )
:m NOOP Z Z NADDR ;m ( -- : No operation )
:m ZERO dup 2/ t, 2/ t, NADDR ;m ( a -- : zero a location )
:m PUT 2/ t, -1 t, NADDR ;m ( a -- : put a byte )
:m GET 2/ -1 t, t, NADDR ;m ( a -- : get a byte )
:m MOV 2/ >r r@ dup t, t, NADDR 2/ t, Z NADDR r> Z t, NADDR
Z Z NADDR ;m
:m iLOAD there 2/ 3 4 * 3 + + 2* MOV 0 swap MOV ;m ( a a -- )
:m iJMP there 2/ E + 2* MOV Z Z NADDR ;m ( a -- )
:m iSTORE ( a a -- )
swap >r there 2/ 24 + 2dup 2* MOV 2dup 1+ 2* MOV 7 + 2* MOV
r> 0 MOV ;m
assembler.1 +order definitions
: begin talign there ; ( -- a )
: again JMP ; ( a -- )
: mark there 0 t, ; ( -- a : create hole in dictionary )
: if ( a -- a : NB. "if" does not work for 8000 )
2/ dup t, Z there 2/ 4 + dup t, Z Z 6 + t, Z Z NADDR Z t,
mark ;
: until 2/ dup t, Z there 2/ 4 + dup t, Z Z 6 + t,
Z Z NADDR Z t, 2/ t, ; ( a -- a )
: +if Z 2/ t, mark ; ( a -- a )
: -if 2/ t, Z there 2/ 4 + t, Z Z there 2/ 4 + t, Z Z mark ;
: then begin 2/ swap t! ; ( a -- )
: while if swap ; ( a a -- a a )
: repeat JMP then ; ( a a -- )
assembler.1 -order
meta.1 +order definitions
0 t, 0 t, \ both locations must be zero
label: entry \ used to set entry point in next cell
-1 t, \ system entry point
B tvar {options} \ bit #1=echo off, #2 = checksum on,
\ #4=info, #8=die on EOF
0 tvar primitive \ any address lower must be a VM primitive
=stksz half tvar stacksz \ must contain $80
-1 tvar neg1 \ must contain -1
1 tvar one \ must contain 1
2 tvar two \ must contain 2
10 tvar bwidth \ must contain 16
0 tvar r0 \ working pointer 1 (register r0)
0 tvar r1 \ register 1
0 tvar r2 \ register 2
0 tvar r3 \ register 3
0 tvar r4 \ register 4
0 tvar r5 \ register 5
0 tvar r6 \ register 6
0 tvar r7 \ register 7
0 tvar h \ dictionary pointer
=thread half tvar {up} \ Current task addr. (Half size)
0 tvar check \ used for system checksum
0 tvar {context} E tallot \ vocabulary context
0 tvar {current} \ vocabulary to add new definitions to
0 tvar {forth-wordlist} \ forth word list (main vocabulary)
0 tvar {editor} \ editor vocabulary
0 tvar {root-voc} \ absolute minimum vocabulary
0 tvar {system} \ system functions vocabulary
0 tvar {cold} \ entry point of VM program, set later on
0 tvar {last} \ last defined word
0 tvar {cycles} \ number of times we have switched tasks
0 tvar {single} \ is multi processing off?
0 tvar {user} \ Number of locals assigned
\ Thread variables, not all of which are user variables
0 tvar ip \ instruction pointer
0 tvar tos \ top of stack
=thread =stksz + half dup tvar {rp0} tvar {rp}
=thread =stksz double + half dup tvar {sp0} tvar {sp}
200 constant =tib \ Start of terminal input buffer
380 constant =num \ Start of numeric input buffer
tuser {next-task} \ next task in task list
tuser {ip-save} \ saved instruction pointer
tuser {tos-save} \ saved top of variable stack
tuser {rp-save} \ saved return stack pointer
tuser {sp-save} \ saved variable stack pointer
tuser {handler} \ throw/catch handler
tuser {sender} \ multitasking; msg. send, 0 = no message
tuser {message} \ multitasking; the message itself
tuser {id} \ executing from block or terminal?
:m INC 2/ neg1 2/ t, t, NADDR ;m ( b -- )
:m DEC 2/ one 2/ t, t, NADDR ;m ( b -- )
:m ONE! dup ZERO INC ; ( a -- : set address to '1' )
:m NG1! dup ZERO DEC ; ( a -- : set address to '-1' )
:m ++sp {sp} DEC ;m ( -- : grow variable stack )
:m --sp {sp} INC ;m ( -- : shrink variable stack )
:m --rp {rp} DEC ;m ( -- : shrink return stack )
:m ++rp {rp} INC ;m ( -- : grow return stack )
:m a-optim drop ;m \ >r there =cell - r> 2/ t! ;m ( a -- )
( Error message string "Error: Not a 16-bit SUBLEQ VM" )
1F tvar err-str
45 t, 72 t, 72 t, 6F t, 72 t, 3A t, 20 t, 4E t,
6F t, 74 t, 20 t, 61 t, 20 t, 31 t, 36 t, 2D t,
62 t, 69 t, 74 t, 20 t, 53 t, 55 t, 42 t, 4C t,
45 t, 51 t, 20 t, 56 t, 4D t, 0D t, 0A t,
err-str 2/ tvar err-str-addr
assembler.1 +order
label: die
err-str-addr r1 MOV
r0 ZERO
err-str r0 MOV
begin
r0
while
r0 DEC
r1 INC
r4 r1 iLOAD
r4 PUT
repeat
HALT
label: start \ System Entry Point
start 2/ entry t! \ Set the system entry point
r1 ONE!
r0 ONE!
label: chk16
r0 r0 ADD \ r0 = r0 * 2
r1 INC \ r1++
r0 +if chk16 JMP then \ check if still positive
bwidth r1 SUB r1 if die JMP then \ r1 - bwidth should be zero
{sp0} {sp} MOV \ Setup initial variable stack
{rp0} {rp} MOV \ Setup initial return stack
{cold} ip MOV \ Get the first instruction to execute
( fall-through )
label: vm ( Forth Inner Interpreter )
ip r0 MOV \ Move Instruction Pointer To Working Ptr.
ip INC \ IP now points to next instruction!
r1 r0 iLOAD \ Get actual instruction to execute
r1 r0 MOV \ Copy it, as SUB is destructive
primitive r1 SUB \ Check if it is a primitive
r1 -if r0 iJMP then \ Jump straight to VM functions if it is
++rp \ If it wasn't a VM instruction, inc {rp}
ip {rp} iSTORE \ and store ip to return stack
r0 ip MOV vm a-optim \ "w" becomes our next instruction
vm JMP \ Ad infinitum...
assembler.1 -order
:m ;a (fall-through); vm a-optim vm JMP ;m
:a bye HALT (a); ( -- : HALT system )
( :a opPush ++sp tos {sp} iSTORE tos ip iLOAD ip INC ;a )
:a opSwap tos r0 MOV tos {sp} iLOAD r0 {sp} iSTORE ;a
:a opDup ++sp tos {sp} iSTORE ;a ( n -- n n )
:a opFromR ++sp tos {sp} iSTORE tos {rp} iLOAD --rp ;a
:a opToR ++rp tos {rp} iSTORE (fall-through);
:a opDrop tos {sp} iLOAD --sp ;a ( n -- )
:a [@] tos tos iLOAD ;a
:a [!] r0 {sp} iLOAD r0 tos iSTORE --sp t' opDrop JMP (a);
:a opEmit tos PUT t' opDrop JMP (a);
( :a opKey ++sp tos {sp} iSTORE tos GET ;a ) ( -- n )
:a - r0 {sp} iLOAD tos r0 SUB r0 tos MOV --sp ;a ( n n -- n )
:a + r0 {sp} iLOAD r0 tos ADD --sp ;a ( n n -- n )
:a opExit ip {rp} iLOAD (fall-through); ( R: a -- )
:a rdrop --rp ;a ( R: u -- )
:a r@ ++sp tos {sp} iSTORE tos {rp} iLOAD ;a ( R: u --, -- u )
:a rp@ ++sp tos {sp} iSTORE {rp} tos MOV ;a ( R: ???, -- u )
:a rp! tos {rp} MOV t' opDrop JMP (a); ( u -- R: ??? )
:a sp! tos {sp} MOV ;a ( u -- ??? )
:a opJumpZ ( u -- : Conditional jump on zero )
r2 ZERO
tos if r2 NG1! then tos DEC tos +if r2 NG1! then
tos {sp} iLOAD --sp
r2 if ip INC vm JMP then (fall-through);
:a opJump ip ip iLOAD ;a ( -- : Unconditional jump )
:a opNext r0 {rp} iLOAD ( R: n -- | n-1 )
r0 if r0 DEC r0 {rp} iSTORE t' opJump JMP then
ip INC --rp ;a
:a op0=
tos r0 MOV tos NG1!
r0 if tos ZERO then r0 DEC r0 +if tos ZERO then ;a
:a op0> tos +if tos NG1! vm JMP then tos ZERO ;a
:a op0<
tos r0 MOV tos ZERO
r0 -if tos NG1! then r0 INC r0 -if tos NG1! then ;a
:a rshift
bwidth r0 MOV
tos r0 SUB
tos {sp} iLOAD --sp
r1 ZERO
begin r0 while
r1 r1 ADD
tos r2 MOV r3 ZERO
r2 -if r3 NG1! then r2 INC r2 -if r3 NG1! then
r3 if r1 INC then
tos tos ADD
r0 DEC
repeat
r1 tos MOV ;a
:a opMux
bwidth r0 MOV
r1 ZERO
r3 {sp} iLOAD --sp
r4 {sp} iLOAD --sp
begin r0 while
r1 r1 ADD
tos r5 MOV r6 ZERO
r5 -if r6 NG1! then r5 INC r5 -if r6 NG1! then
r6 -if
r4 r7 MOV r5 ZERO
r7 -if r5 ONE! then r7 INC r7 -if r5 ONE! then
r5 r1 ADD
then
r6 INC
r6 if
r3 r7 MOV r5 ZERO
r7 -if r5 ONE! then r7 INC r7 -if r5 ONE! then
r5 r1 ADD
then
tos tos ADD
r3 r3 ADD
r4 r4 ADD
r0 DEC
repeat
r1 tos MOV ;a
:a opDivMod
r0 {sp} iLOAD
r2 ZERO
begin
r1 ONE!
r0 -if r1 ZERO then
r1
while
r2 INC
tos r0 SUB
repeat
tos r0 ADD
r2 DEC
r2 tos MOV
r0 {sp} iSTORE ;a
:a pause
{single} if vm JMP then \ Do nothing if single-threaded mode
r0 {up} iLOAD \ load next task pointer from user storage
r0 if
{cycles} INC \ increment "pause" count
{up} r2 MOV r2 INC \ load TASK pointer, skip next task loc
ip r2 iSTORE r2 INC \ save registers to current task
tos r2 iSTORE r2 INC
{rp} r2 iSTORE r2 INC
{sp} r2 iSTORE r2 INC
r0 {rp0} MOV stacksz {rp0} ADD \ change {rp0} to new loc
{rp0} {sp0} MOV stacksz {sp0} ADD \ same but for {sp0}
r0 {up} MOV r0 INC \ set next task
ip r0 iLOAD r0 INC \ reverse of save registers
tos r0 iLOAD r0 INC
{rp} r0 iLOAD r0 INC
{sp} r0 iLOAD r0 INC \ we're all golden
then ;a
there 2/ primitive t!
:m munorder target.only.1 -order talign ;m
:m (;t)
CAFE <> if abort" Unstructured" then
munorder ;m
:m ;t (;t) opExit ;m
:m :s tlast @ {system} t@ tlast ! F00D :t drop 0 ;m
:m :so tlast @ {system} t@ tlast ! F00D :to drop 0 ;m
:m ;s drop CAFE ;t F00D <> if abort" unstructured" then
tlast @ {system} t! tlast ! ;m
:m :r tlast @ {root-voc} t@ tlast ! BEEF :t drop 0 ;m
:m ;r drop CAFE ;t BEEF <> if abort" unstructured" then
tlast @ {root-voc} t! tlast ! ;m
:m :e tlast @ {editor} t@ tlast ! DEAD :t drop 0 ;m
:m ;e drop CAFE ;t DEAD <> if abort" unstructured" then
tlast @ {editor} t! tlast ! ;m
:m system[ tlast @ {system} t@ tlast ! BABE ;m
:m ]system BABE <> if abort" unstructured" then
tlast @ {system} t! tlast ! ;m
:m root[ tlast @ {root-voc} t@ tlast ! D00D ;m
:m ]root D00D <> if abort" unstructured" then
tlast @ {root-voc} t! tlast ! ;m
:m : :t ;m ( -- ???, "name" : start cross-compilation )
:m ; ;t ;m ( ??? -- : end cross-compilation of a target word )
:m begin talign there ;m ( -- a )
:m until talign opJumpZ 2/ t, ;m ( a -- )
:m again talign opJump 2/ t, ;m ( a -- )
:m if opJumpZ there 0 t, ;m ( -- a )
:m tmark opJump there 0 t, ;m ( -- a )
:m then there 2/ swap t! ;m ( a -- )
:m else tmark swap then ;m ( a -- a )
:m while if ;m ( -- a )
:m repeat swap again then ;m ( a a -- )
:m aft drop tmark begin swap ;m ( a -- a a )
:m next talign opNext 2/ t, ;m ( a -- )
:m for opToR begin ;m ( -- a )
:m =jump [ t' opJump half ] literal ;m ( -- a )
:m =jumpz [ t' opJumpZ half ] literal ;m ( -- a )
:m =unnest [ t' opExit half ] literal ;m ( -- a )
:m =>r [ t' opToR half ] literal ;m ( -- a )
:m =next [ t' opNext half ] literal ;m ( -- a )
:m dup opDup ;m ( -- : compile opDup into the dictionary )
:m drop opDrop ;m ( -- : compile opDrop into the dictionary )
:m swap opSwap ;m ( -- : compile opSwap into the dictionary )
:m >r opToR ;m ( -- : compile opTorR into the dictionary )
:m r> opFromR ;m ( -- : compile opFromR into the dictionary )
:m 0= op0= ;m ( -- : compile op0= into the dictionary )
:m 0< op0< ;m ( -- : compile op0< into the dictionary )
:m 0> op0> ;m ( -- : compile op0> into the dictionary )
:m mux opMux ;m ( -- : compile opMux into the dictionary )
:m exit opExit ;m ( -- : compile opExit into the dictionary )
:to + + ; ( n n -- n : addition )
:to - - ; ( n1 n2 -- n : subtract n2 from n1 )
:to bye bye ; ( -- : halt the system )
:to dup dup ; ( n -- n n : duplicate top of variable stack )
:to drop opDrop ; ( n -- : drop top of variable stack )
:to swap opSwap ; ( x y -- y x : swap two variables on stack )
:to rshift rshift ; ( u n -- u : logical right shift by "n" )
:so [@] [@] ;s ( vma -- : fetch -VM Address- )
:so [!] [!] ;s ( u vma -- : store to -VM Address- )
:to sp! sp! ; ( a -- ??? : set the variable stack location )
:to 0= op0= ; ( n -- f : equal to zero )
:to 0< op0< ; ( n -- f : signed less than zero )
:to 0> op0> ; ( n -- f : signed greater than zero )
:so mux opMux ;s ( u1 u2 sel -- u : bitwise multiplex op. )
:so pause pause ;s ( -- : pause current task, task switch )
: 2* dup + ; ( u -- u : multiply by two )
:s (const) r> [@] ;s compile-only ( R: a --, -- u )
:m constant :t mdrop (const) t, munorder ;m
system[
0 constant #0 ( -- 0 : push the number zero onto the stack )
1 constant #1 ( -- 1 : push one onto the stack )
-1 constant #-1 ( -- -1 : push negative one onto the stack )
2 constant #2 ( -- 2 : push two onto the stack )
]system
: 1+ #1 + ; ( n -- n : increment value in cell )
: 1- #1 - ; ( n -- n : decrement value in cell )
:s (push) r> dup [@] swap 1+ >r ;s
:m lit (push) t, ;m ( n -- : compile a literal )
:s (up)
r> dup [@] {up} half lit [@] + 2* swap 1+ >r ;s
compile-only
:s (var) r> 2* ;s compile-only ( R: a --, -- a )
:s (user) r> [@] {up} half lit [@] + 2* ;s compile-only
( R: a --, -- u )
:m up (up) t, ;m ( n -- : compile user variable )
:m [char] char (push) t, ;m ( --, "name" : compile char )
:m char char (push) t, ;m ( --, "name" : compile char )
:m variable :t mdrop (var) 0 t, munorder ;m
:m user :t mdrop (user) local? =cell lallot t, munorder ;m
:to ) ; immediate
: over swap dup >r swap r> ; ( n1 n2 -- n1 n2 n1 )
: invert #0 swap - 1- ; ( u -- u : bitwise invert )
: xor >r dup invert swap r> mux ; ( u u -- u : bitwise xor )
: or over mux ; ( u u -- u : bitwise or )
: and #0 swap mux ; ( u u -- u : bitwise and )
: 2/ #1 rshift ; ( u -- u : divide by two )
: @ 2/ [@] ; ( a -- u : fetch a cell to a memory location )
: ! 2/ [!] ; ( u a -- : write a cell to a memory location )
:s @+ dup @ ;s ( a -- a u : non-destructive load )
user <ok> ( -- a : okay prompt xt loc. )
system[
user <emit> ( -- a : emit xt loc. )
user <key> ( -- a : key xt loc. )
user <echo> ( -- a : echo xt loc. )
user <literal> ( -- a : literal xt loc. )
user <tap> ( -- a : tap xt loc. )
user <expect> ( -- a : expect xt loc. )
user <error> ( -- a : <error> xt container. )
]system
:s <cold> {cold} lit ;s ( -- a : cold xt loc. )
: current {current} lit ; ( -- a : get current vocabulary )
: root-voc {root-voc} lit ; ( -- a : get root vocabulary )
: this 0 up ; ( -- a : address of task thread memory )
: pad this 3C0 lit + ; ( -- a : index into pad area )
: #vocs 8 lit ; ( -- u : number of vocabularies )
: context {context} lit ; ( -- a )
variable blk ( -- a : latest loaded block )
variable scr ( -- a : latest listed block )
2F t' blk >tbody t!
2F t' scr >tbody t!
user base ( -- a : push the radix for numeric I/O )
user dpl ( -- a : decimal point variable )
user hld ( -- a : index to hold space for num. I/O)
user state ( -- f : interpreter state )
user >in ( -- a : input buffer position var )
user span ( -- a : number of chars saved by expect )
$20 constant bl ( -- 32 : push space character )
system[
h constant h? ( -- a : push the location of dict. ptr )
{cycles} constant cycles ( -- a : number of "cycles" ran for )
{sp} constant sp ( -- a : address of v.stk ptr. )
{user} constant user? ( -- a : )
variable calibration F00 t' calibration >tbody t!
]system
:s radix base @ ;s ( -- u : retrieve base )
: here h? @ ; ( -- u : push the dictionary pointer )
: sp@ sp @ 1+ ; ( -- a : Fetch variable stack pointer )
: hex $10 lit base ! ; ( -- : change to hexadecimal base )
: decimal $A lit base ! ; ( -- : change to decimal base )
: ] #-1 state ! ; ( -- : return to compile mode )
: [ #0 state ! ; immediate ( -- : initiate command mode )
: nip swap drop ; ( x y -- y : remove second item on stack )
: tuck swap over ; ( x y -- y x y : save item for rainy day )
: ?dup dup if dup then ; ( x -- x x | 0 : conditional dup )
: rot >r swap r> swap ; ( x y z -- y z x : "rotate" stack )
: -rot rot rot ; ( x y z -- z x y : "rotate" stack backwards )
: 2drop drop drop ; ( x x -- : drop it like it is hot )
: 2dup over over ; ( x y -- x y x y )
:s shed rot drop ;s ( x y z -- y z : drop third stack item )
: > - 0> ; ( n1 n2 -- f : signed greater than )
: < swap > ; ( n1 n2 -- f : signed less than )
: = - 0= ; ( u1 u2 -- f : equality )
: <> = 0= ; ( u1 u2 -- f : inequality )
: 0<> 0= 0= ; ( n -- f : not equal to zero )
: 0<= 0> 0= ; ( n -- f : less than or equal to zero )
: 0>= 0< 0= ; ( n1 n2 -- f : greater or equal to zero )
: >= < 0= ; ( n1 n2 -- f : greater than or equal to )
: <= > 0= ; ( n1 n2 -- f : less than or equal to )
: u< 2dup 0>= swap 0>= <> >r < r> <> ; ( u1 u2 -- f )
: u> swap u< ; ( u1 u2 -- f : unsigned greater than )
: u>= u< 0= ; ( u1 u2 -- f )
: u<= u> 0= ; ( u1 u2 -- f )
: within over - >r - r> u< ; ( u lo hi -- f )
: negate 1- invert ; ( n -- n : twos compliment negation )
: s>d dup 0< ; ( n -- d : signed to double width cell )
: abs s>d if negate then ; ( n -- u : absolute value )
: cell #2 ; ( -- u : push bytes in cells to stack )
: cell+ cell + ; ( a -- a : increment address by cell width )
: cells 2* ; ( u -- u : multiply # of cells to get bytes )
: execute 2/ >r ; ( xt -- : execute an execution token )
:s @execute ( ?dup 0= ?exit ) @ execute ;s ( xt -- )
: ?exit if rdrop then ; compile-only ( u --, R: -- |??? )
: key? #-1 [@] negate ( -- c 0 | -1 : get byte of input )
s>d if
{options} lit @ 8 lit and if bye then drop #0 exit
then #-1 ;
: key begin pause <key> @execute until ; ( -- c )
: emit pause <emit> @execute ; ( c -- : output byte )
: cr =cr lit emit =lf lit emit ; ( -- : emit new line )
: get-current current @ ; ( -- wid : get definitions vocab. )
: set-current current ! ; ( -- wid : set definitions vocab. )
:s last get-current @ ;s ( -- wid : get last defined word )
: pick sp@ + [@] ; ( nu...n0 u -- nu : pick item on stack )
: +! 2/ tuck [@] + swap [!] ; ( u a -- : add val to cell )
: lshift begin ?dup while 1- swap 2* swap repeat ; ( n u -- n )
: c@ @+ swap #1 and if 8 lit rshift exit then FF lit and ;
: c! swap FF lit and dup 8 lit lshift or swap
tuck @+ swap #1 and 0= FF lit xor
>r over xor r> and xor swap ! ; ( c a -- character store )
:s c@+ dup c@ ;s ( b -- b u : non-destructive 'c@' )
: max 2dup > mux ; ( n1 n2 -- n : highest of two numbers )
: min 2dup < mux ; ( n1 n2 -- n : lowest of two numbers )
: source-id {id} up @ ; ( -- u : input type )
: 2! tuck ! cell+ ! ; ( u1 u2 a -- : store two cells )
: 2@ dup cell+ @ swap @ ; ( a -- u1 u2 : fetch two cells )
: 2>r r> swap >r swap >r >r ; compile-only ( n n --,R: -- n n )
: 2r> r> r> swap r> swap >r ; compile-only ( -- n n,R: n n -- )
system[ user tup =cell tallot ]system
: source tup 2@ ; ( -- a u : get terminal input source )
: aligned dup #1 and 0<> #1 and + ; ( u -- u : align up ptr. )
: align here aligned h? ! ; ( -- : align up dict. ptr. )
: allot h? +! ; ( n -- : allocate space in dictionary )
: , align here ! cell allot ; ( u -- : write value into dict. )
: count dup 1+ swap c@ ; ( b -- b c : advance string )
: +string #1 over min rot over + -rot - ; ( b u -- b u )
: type ( a u -- : print out a string )
begin dup while swap count emit swap 1- repeat 2drop ;
: cmove ( b1 b2 u -- : move character blocks around )
for aft >r c@+ r@ c! 1+ r> 1+ then next 2drop ;
: fill ( b u c -- : write byte 'c' to array 'b' of 'u' length )
swap for swap aft 2dup c! 1+ then next 2drop ;
: erase #0 fill ; ( b u -- : write zeros to array )
:s do$ 2r> 2* dup count + aligned 2/ >r swap >r ;s ( -- a )
:s ($) do$ ;s ( -- a : do string NB. )
:s .$ do$ count type ;s ( -- : print string in next cells )
:m ." .$ $literal ;m ( --, ccc" : compile string )
:m $" ($) $literal ;m ( --, ccc" : compile string )
: space bl emit ; ( -- : emit a space )
: catch ( xt -- exception# | 0 \ return addr on stack )
sp@ >r ( xt ) \ save data stack pointer
{handler} up @ >r ( xt ) \ and previous handler
rp@ {handler} up ! ( xt ) \ set current handler
execute ( ) \ execute returns if no throw
r> {handler} up ! ( ) \ restore previous handler
rdrop ( ) \ discard saved stack ptr
#0 ; ( 0 ) \ normal completion
: throw ( ??? exception# -- ??? exception# )
?dup if ( exc# ) \ 0 throw is no-op
{handler} up @ rp! ( exc# ) \ restore prev ret. stack
r> {handler} up ! ( exc# ) \ restore prev handler
r> swap >r ( saved-sp ) \ exc# on return stack
sp! drop r> ( exc# ) \ restore stack
then ;
: abort #-1 throw ; ( -- : Time to die. )
:s (abort) do$ swap if count type abort then drop ;s ( n -- )
:s depth {sp0} lit @ sp@ - 1- ;s ( -- n )
:s ?depth depth >= -4 lit and throw ;s ( ??? n -- )
: um+ 2dup + >r r@ 0>= >r ( u u -- u carry )
2dup and 0< r> or >r or 0< r> and negate r> swap ;
: dnegate invert >r invert #1 um+ r> + ; ( d -- d )
: d+ >r swap >r um+ r> + r> + ; ( d d -- d )
: um* ( u u -- ud : double cell width multiply )
#0 swap ( u1 0 u2 ) F lit
for
dup um+ >r >r dup um+ r> + r>
if >r over um+ r> + then
next shed ;
: * um* drop ; ( n n -- n : multiply two numbers )
: um/mod ( ud u -- ur uq : unsigned double cell div/mod )
?dup 0= -A lit and throw
2dup u<
if negate F lit
for >r dup um+ >r >r dup um+ r> + dup
r> r@ swap >r um+ r> ( or -> ) 0<> swap 0<> +
if >r drop 1+ r> else drop then r>
next
drop swap exit
then 2drop drop #-1 dup ;
: m/mod ( d n -- r q : floored division )
s>d dup >r
if negate >r dnegate r> then
>r s>d if r@ + then r> um/mod r>
if swap negate swap then ;
: /mod over 0< swap m/mod ; ( u1 u2 -- u1%u2 u1/u2 )
: mod /mod drop ; ( u1 u2 -- u1%u2 )
: / /mod nip ; ( u1 u2 -- u1/u2 )
:s (emit) opEmit ;s ( c -- : output byte to terminal )
: echo <echo> @execute ; ( c -- : emit a single character )
:s tap dup echo over c! 1+ ;s ( bot eot cur c -- bot eot cur )
:s ktap ( bot eot cur c -- bot eot cur )
dup dup =cr lit <> >r =lf lit <> r> and if ( Not EOL? )
dup =bksp lit <> >r =del lit <> r> and if ( Not Del Char? )
bl tap ( replace any other character with bl )
exit
then
>r over r@ < dup if ( if not at start of line )
=bksp lit dup echo bl echo echo ( erase char )
then
r> + ( add 0/-1 to cur )
exit
then drop nip dup ;s ( set cur = eot )
: accept ( b u -- b u : read in a line of user input )
over + over begin
2dup <>
while
key dup bl - 5F lit u< if tap else <tap> @execute then
repeat drop over - ;
: expect <expect> @execute span ! drop ; ( a u -- )
: tib source drop ; ( -- b )
: query tib =buf lit <expect> @execute tup ! drop #0 >in ! ;
: -trailing for aft ( b u -- b u : remove trailing spaces )
bl over r@ + c@ < if r> 1+ exit then
then next #0 ;
:s look ( b u c xt -- b u : skip until *xt* test succeeds )
swap >r -rot
begin
dup
while
over c@ r@ - r@ bl = 4 lit pick execute
if rdrop shed exit then
+string
repeat rdrop shed ;s
:s unmatch if 0> exit then 0<> ;s ( c1 c2 -- t )
:s match unmatch invert ;s ( c1 c2 -- t )
: parse ( c -- b u ; <string> )
>r tib >in @ + tup @ >in @ - r@ ( get memory to parse )
>r over r> swap 2>r
r@ t' unmatch lit look 2dup ( look for start of match )
r> t' match lit look swap ( look for end of match )
r> - >r - r> 1+ ( b u c -- b u delta : compute match len )
>in +!
r> bl = if -trailing then
#0 max ;
:s banner ( +n c -- )
>r begin dup 0> while r@ emit 1- repeat drop rdrop ;s
: hold #-1 hld +! hld @ c! ; ( c -- : save char in hold space )
: #> 2drop hld @ this =num lit + over - ; ( u -- b u )
:s extract ( ud ud -- ud u : extract digit from number )
dup >r um/mod r> swap >r um/mod r> rot ;s
:s digit 9 lit over < 7 lit and + [char] 0 + ;s ( u -- c )
: # #2 ?depth #0 radix extract digit hold ; ( d -- d )
: #s begin # 2dup ( d0= -> ) or 0= until ; ( d -- 0 )
: <# this =num lit + hld ! ; ( -- )
: sign 0>= ?exit [char] - hold ; ( n -- )
: u.r >r #0 <# #s #> r> over - bl banner type ; ( u r -- )
: u. space #0 u.r ; ( u -- : unsigned numeric output )
:s (.) abs radix opDivMod ?dup if (.) then digit emit ;s
: . space s>d if [char] - emit then (.) ; ( n -- )
: >number ( ud b u -- ud b u : convert string to number )
begin
2dup 2>r drop c@ radix ( get next character )
( digit? -> ) >r [char] 0 - 9 lit over <
if 7 lit - dup A lit < or then dup r> u< ( c base -- u f )
0= if ( d char )
drop ( d char -- d )
2r> ( restore string )
exit ( finished...exit )
then ( d char )
swap radix um* drop rot radix um* d+ ( accumulate digit )
2r> ( restore string )
+string dup 0= ( advance, test for end )
until ;
: number? ( a u -- d -1 | a u 0 : easier to use than >number )
#-1 dpl !
radix >r
over c@ [char] - = dup >r if +string then
over c@ [char] $ = if hex +string then
( over c@ [char] # = if decimal +string then )
2>r #0 dup 2r>
begin
>number dup
while over c@ [char] . <>
if shed rot r> 2drop #0 r> base ! exit then
1- dpl ! 1+ dpl @
repeat
2drop r> if dnegate then r> base ! #-1 ;
: .s depth for aft r@ pick . then next ; ( -- : show stack )
: compare ( a1 u1 a2 u2 -- n : string equality )
rot
over - ?dup if >r 2drop r> nip exit then
for ( a1 a2 )
aft
count rot count rot - ?dup
if rdrop nip nip exit then
then
next 2drop #0 ;
: nfa cell+ ; ( pwd -- nfa : move word ptr to name field )
: cfa ( pwd -- cfa : move to Code Field Address )
nfa c@+ 1F lit and + cell+ cell negate and ;
:s (search) ( a wid -- PWD PWD 1 | PWD PWD -1 | 0 a 0 )
\ Search for word "a" in "wid"
swap >r dup
begin
dup
while
dup nfa count 9F lit ( $1F:word-length + $80:hidden )
and r@ count compare 0=
if ( found! )
rdrop
dup ( immediate? -> ) nfa 40 lit swap @ and 0<>
#1 or negate exit
then
nip @+
repeat
rdrop 2drop #0 ;s
:s (find) ( a -- pwd pwd 1 | pwd pwd -1 | 0 a 0 : find a word )
>r
context
begin
@+
while
@+ @ r@ swap (search) ?dup
if
>r shed r> rdrop exit
then
cell+
repeat drop #0 r> #0 ;s
: search-wordlist ( a wid -- PWD 1|PWD -1|a 0 )
(search) shed ;
: find ( a -- pwd 1 | pwd -1 | a 0 : find word in dictionary )
(find) shed ;
: compile r> dup [@] , 1+ >r ; compile-only ( -- )
:s (literal) state @ if compile (push) , then ;s
: literal <literal> @execute ; immediate ( u -- )
: compile, align 2/ , ; ( xt -- )
:s ?found ?exit ( b f -- b | ??? )
space count type [char] ? emit cr -D lit throw ;s
: interpret ( b -- )
find ?dup if
state @
if
0> if cfa execute exit then \ <- execute immediate words
cfa compile, exit \ <- compiling word are...compiled.
then
drop
dup nfa c@ 20 lit and 0<> -E lit and throw ( <- ?compile )
\ if it's not compiling, execute it then exit *interpreter*
cfa execute exit
then
\ not a word
dup >r count number? if rdrop \ it is numeric!
dpl @ 0< if \ <- dpl is -1 if it's a single cell number
drop \ drop high cell from 'number?' for single cell
else \ <- dpl is not -1, it is a double cell number
state @ if swap then
postpone literal \ literal executed twice if # is double
then \ NB. "literal" is state aware
postpone literal exit
then
\ NB. Could vector ?found here, to handle arbitrary words
r> #0 ?found ;
: get-order ( -- widn...wid1 n : get current search order )
context
\ next line finds first empty cell
#0 >r begin @+ r@ xor while cell+ repeat rdrop
dup cell - swap
context - 2/ dup >r 1- s>d -$32 lit and throw
for aft @+ swap cell - then next @ r> ;
:r set-order ( widn ... wid1 n -- : set current search order )
\ NB. Uses recursion, however the meta-compiler does not use
\ the Forth compilation mechanism, so the current definition
\ of "set-order" is available immediately.
dup #-1 = if drop root-voc #1 set-order exit then
dup #vocs > -$31 lit and throw
context swap for aft tuck ! cell+ then next #0 swap ! ;r
: (order) ( w wid*n n -- wid*n w n )
dup if
1- swap >r ( recurse -> ) (order) over r@ xor
if 1+ r> -rot exit then rdrop
then ;
: -order get-order (order) nip set-order ; ( wid -- )
: +order dup >r -order get-order r> swap 1+ set-order ;
root[
{forth-wordlist} constant forth-wordlist ( -- wid )
{system} constant system ( -- wid )
]root
:r forth root-voc forth-wordlist #2 set-order ;r ( -- )
:r only #-1 set-order ;r ( -- : set minimal search order )
:s .id ( pwd -- : print word )
nfa count 1F lit and type space ;s
:r words ( -- )
cr get-order
begin ?dup while swap ( dup u. ." : " ) @
begin ?dup
while dup nfa c@ 80 lit and 0= if dup .id then @
repeat ( cr )
1- repeat ;r
: definitions context @ set-current ; ( -- )
: word ( -- b )
#1 ?depth parse here aligned dup >r 2dup ! 1+ swap cmove r> ;
:s token bl word ;s ( -- b )
:s ?unique ( a -- a : warn if word definition is not unique )
dup get-current (search) 0= ?exit space
2drop {last} lit @ .id ." redefined" cr ;s ( b -- b )
:s ?nul c@+ ?exit -$10 lit throw ;s ( b -- b )
:s ?len c@+ 1F lit > -$13 lit and throw ;s ( b -- b )
:to char token ?nul count drop c@ ; ( "name", -- c )
:to [char] postpone char compile (push) , ; immediate
:to ;
CAFE lit <> -$16 lit and throw ( check compile safety )
=unnest lit , ( compile exit )
postpone [ ( back to command mode )
?dup if ( link word in if non 0 )
get-current ! ( this inks the word in )
then ; immediate compile-only
:to : ( "name", -- colon-sys )
align ( must be aligned before hand )
here dup ( push location for ";" )
{last} lit ! ( set last defined word )
last , ( point to previous word in header )
token ?nul ?len ?unique ( parse word and do basic checks )
count + h? ! align ( skip over packed word and align )
CAFE lit ( push constant for compiler safety )
postpone ] ; ( turn compile mode on )
:to :noname align here #0 CAFE lit ] ; ( "name", -- xt )
:to ' token find ?found cfa literal ; immediate
:to recurse {last} lit @ cfa compile, ; immediate compile-only
:s toggle tuck @ xor swap ! ;s ( u a -- : toggle bits at addr )
:s hide token find ?found nfa 80 lit swap toggle ;s
:s mark here #0 , ;s compile-only
:to begin here ; immediate compile-only
:to if =jumpz lit , mark ; immediate compile-only
:to until 2/ postpone if ! ; immediate compile-only
:to again =jump lit , compile, ; immediate compile-only
:to then here 2/ swap ! ; immediate compile-only
:to while postpone if ; immediate compile-only
:to repeat swap postpone again postpone then ;
immediate compile-only
:to else =jump lit , mark swap postpone then ;
immediate compile-only
:to for =>r lit , here ; immediate compile-only
:to aft drop =jump lit , mark here swap ;
immediate compile-only
:to next =next lit , compile, ; immediate compile-only
:s (marker) r> 2* @+ h? ! cell+ @ get-current ! ;s compile-only
: create postpone : drop postpone [ compile (var)
get-current ! ;
:to variable create #0 , ;
:to constant create cell negate allot compile (const) , ;
:to user create cell negate allot compile (user)
user? @ , #1 user? +! ;
: >body cell+ ; ( a -- a : move to a create words body )
:s (does) r> r> 2* swap >r ;s compile-only
:s (comp)
r> {last} lit @ cfa
( check we are running does> on a created word )
@+ to' (var) half lit <> -$1F lit and throw
! ;s compile-only
: does> compile (comp) compile (does) ;
immediate compile-only
:to marker last align here create cell negate allot compile
(marker) , , ; ( --, "name" )
:to rp! compile rp! ; immediate compile-only
:to rp@ compile rp@ ; immediate compile-only
:to >r compile opToR ; immediate compile-only
:to r> compile opFromR ; immediate compile-only
:to r@ compile r@ ; immediate compile-only
:to rdrop compile rdrop ; immediate compile-only
:to exit compile opExit ; immediate compile-only
:s (s) align [char] " word count nip 1+ allot align ;s
:to ." compile .$ (s) ; immediate compile-only
:to $" compile ($) (s) ; immediate compile-only
:to abort" compile (abort) (s) ; immediate compile-only
:to ( [char] ) parse 2drop ; immediate ( c"xxx" -- )
:to .( [char] ) parse type ; immediate ( c"xxx" -- )
:to \ tib @ >in ! ; immediate ( c"xxx" -- )
:to postpone token find ?found cfa compile, ; immediate
:s (nfa) last nfa toggle ;s ( u -- )
:to immediate 40 lit (nfa) ; ( -- : mark prev word as immed. )
:to compile-only 20 lit (nfa) ; ( -- )
:to see token find ?found cr ( --, "name" : decompile word )
begin @+ =unnest lit <>
while @+ . cell+ here over < if drop exit then
repeat @ u. ;
:to dump aligned ( a u -- : display section of memory )
begin ?dup
while swap @+ . cell+ swap cell -
repeat drop ;
:s cksum aligned dup C0DE lit - >r ( a u -- u )
begin ?dup
while swap @+ r> + >r cell+ swap cell -
repeat drop r> ;s
: defined token find nip 0<> ; ( -- f )
:to [then] ; immediate ( -- )
:to [else]
begin
begin token c@+ while
find drop cfa dup to' [else] lit = swap to' [then] lit = or
?exit repeat query drop again ; immediate
:to [if] ?exit postpone [else] ; immediate
: ms for pause calibration @ for next next ; ( ms -- )
: bell 7 lit emit ; ( -- : emit ASCII BEL character )
:s csi 1B lit emit 5B lit emit ;s ( -- : ANSI Term. Esc. Seq. )
: page csi ." 2J" csi ." 1;1H" ( csi ." 0m" ) ;
: at-xy radix decimal ( x y -- : set cursor position )
>r csi #0 u.r ." ;" #0 u.r ." H" r> base ! ;
( system[ variable dirty ]system )
: b/buf 400 lit ; ( -- u : size of the block buffer )
: block #1 ?depth dup blk ! A lit lshift pause ; ( k -- u )
: flush ( dirty @ if save-buffers empty-buffers then ) ;
: update ( #-1 dirty ! ) ; ( -- : mark cur. buf. as dirty )
: blank bl fill ; ( a u -- : blank an area of memory )
: list ( k -- : display a block )
page cr ( clean the screen )
dup scr ! block ( update "scr" and load block )
F lit for ( for each line in the block )
F lit r@ - 3 lit u.r space ( print the line number )
40 lit 2dup type cr + ( print line )
( 3F lit for count emit next cr \ print line )
next drop ;
: get-input source >in @ source-id <ok> @ ; ( -- n1...n5 )
: set-input <ok> ! {id} up ! >in ! tup 2! ; ( n1...n5 -- )
:s ok state @ ?exit ." ok" cr ;s ( -- : okay prompt )
:s eval ( "word" -- )
begin token c@+ while
interpret #0 ?depth
repeat drop <ok> @execute ;s
: evaluate ( a u -- : evaluate a string )
get-input 2>r 2>r >r ( save the current input state )
#0 #-1 to' ) lit set-input ( set new input )
t' eval lit catch ( evaluate the string )
r> 2r> 2r> set-input ( restore input state )
throw ; ( throw on error )
:s line 6 lit lshift swap block + 40 lit ;s ( k l -- a u )
:s loadline line evaluate ;s ( k l -- ??? : execute a line! )
: load #0 F lit for
2dup 2>r loadline 2r> 1+ next 2drop ; ( k -- : exec blk )
:r eforth 0109 lit ;r ( --, version )
:s info cr ( --, print system info )
." eForth v1.9, Public Domain," here . cr
." Richard James Howe, howe.r.j.89@gmail.com" cr
." https://github.com/howerj/subleq" cr ;s
:s xio t' accept lit <expect> ! <tap> ! <echo> ! <ok> ! ;s
:s hand t' ok lit
t' (emit) lit ( Default: echo on )
{options} lit @ #1 and if drop to' drop lit then
t' ktap lit postpone [ xio ;s ( -- )
:s pace B lit emit ;s ( -- : emit pacing character )
:s file t' pace lit to' drop lit t' ktap lit xio ;s ( -- )
:s console t' key? lit <key> ! t' (emit) lit <emit> ! hand ;s
:s io! console ;s ( -- : setup system I/O )
:s task-init ( task-addr -- : initialize USER task )
{up} lit @ swap {up} lit !
this 2/ {next-task} up !
to' bye lit 2/ {ip-save} up ! ( Default execution token )
this =stksz lit + 2/ {rp-save} up !
this =stksz double lit + 2/ {sp-save} up !
#0 {tos-save} up !
decimal
io!
t' (literal) lit <literal> !
to' bye lit <error> !
#0 >in ! #-1 dpl !
this =tib lit + #0 tup 2! \ Set terminal input buffer loc.
{up} lit ! ;s
:s ini {up} lit @ task-init ;s ( -- : initialize current task )
:s (error) ( u -- : quit loop error handler )
dup space . [char] ? emit cr #-1 = if bye then
ini t' (error) lit <error> ! ;s
: quit ( -- : interpreter loop )
t' (error) lit <error> ! ( set error handler )
begin ( infinite loop start... )
query t' eval lit catch ( evaluate a line )
?dup if <error> @execute then ( error? )
again ; ( do it all again... )
:s (cold) ( -- : Forth boot sequence )
forth definitions ( un-mess-up dictionary / set it )
ini ( initialize the current thread correctly )
{options} lit @ 4 lit and if info then ( display info? )
{options} lit @ #2 and if ( checksum on? )
primitive lit @ 2* dup here swap - cksum ( calc. cksum )
check lit @ <> if ." bad cksum" bye then ( oops... )
{options} lit @ #2 xor {options} lit ! ( disable cksum )
then quit ;s ( call the interpreter loop AKA "quit" )
:s task: ( "name" -- : create a named task )
create here b/buf allot 2/ task-init ;s
:s activate ( xt task-address -- : start task executing xt )
dup task-init
dup >r swap 2/ swap {ip-save} lit + ! ( set execution word )
r> this @ >r dup 2/ this ! r> swap ! ;s ( link in task )
:s wait ( addr -- : wait for signal )
begin pause @+ until #0 swap ! ;s
:s signal this swap ! ;s ( addr -- : signal to wait )
:s single #1 {single} lit ! ;s ( -- : disable other tasks )
:s multi #0 {single} lit ! ;s ( -- : enable multitasking )
:s send ( msg task-addr -- : send message to task )
this over {sender} lit +
begin pause @+ 0= until
! {message} lit + ! ;s
:s receive ( -- msg task-addr : block until message )
begin pause {sender} up @ until
{message} up @ {sender} up @
#0 {sender} up ! ;s
: editor {editor} lit #1 set-order ; ( Micro BLOCK editor )
:e q only forth ;e ( -- : exit back to Forth interpreter )
:e ? scr @ . ;e ( -- : print block number of current block )
:e l scr @ list ;e ( -- : list current block )
:e e q scr @ load editor ;e ( -- : evaluate current block )
:e ia #2 ?depth 6 lit lshift + scr @ block + tib >in @ +
swap source nip >in @ - cmove tib @ >in ! update l ;e
:e i #0 swap ia ;e ( line --, "line" : insert line at )
:e w words ;e ( -- : display block editor commands )
:e s update flush ;e ( -- : save edited block )
:e n #1 scr +! l ;e ( -- : display next block )
:e p #-1 scr +! l ;e ( -- : display previous block )
:e r scr ! l ;e ( k -- : retrieve given block )
:e x scr @ block b/buf blank l ;e ( -- : erase current block )
:e d #1 ?depth >r scr @ block r> 6 lit lshift + 40 lit
blank l ;e ( line -- : delete line )
: cold {cold} lit 2* @execute ; ( -- )
t' (cold) half {cold} t! \ Set starting Forth word
atlast {forth-wordlist} t! \ Make wordlist work
{forth-wordlist} {current} t! \ Set "current" dictionary
there h t! \ Assign dictionary pointer
local? {user} t! \ Assign number of locals
primitive t@ double mkck check t! \ Set checksum over Forth
atlast {last} t! \ Set last defined word
save-target \ Output target
.end \ Get back to normal Forth
bye \ Auf Wiedersehen
\end{lstlisting}
Running this code in the interpreter will produce a list of signed decimal integers in the range of -32768 to 32767 that will match the binary.
\pagebreak
\section{Binary}
Every 4 hex characters represent 1 word. They are signed and in big endian (0001 = 1, ffff = -1, 1234 = 4660).
\hfill \break
\texttt{0000 | 0000 0000 009c 000b 09a8 0080 ffff 0001 0002 0010 0000 0000 0000 0000 0000 0000} \\
\texttt{0010 | 0000 0000 3230 7e00 7c59 0000 0000 0000 0000 0000 0000 0000 0000 003c 321e 31fa} \\
\texttt{0020 | 2d98 30f2 17e2 321e 0000 0000 0030 0000 0000 7e80 7e80 7f00 7f00 001f 0045 0072} \\
\texttt{0030 | 0072 006f 0072 003a 0020 004e 006f 0074 0020 0061 0020 0031 0036 002d 0062 0069} \\
\texttt{0040 | 0074 0020 0053 0055 0042 004c 0045 0051 0020 0056 004d 000d 000a 002d 000b 000b} \\
\texttt{0050 | 0051 004d 0000 0054 0000 000b 0057 0000 0000 005a 000a 000a 005d 000a 000a 0060} \\
\texttt{0060 | 002d 0000 0063 0000 000a 0066 0000 0000 0069 000a 0000 006f 0000 0000 0075 0000} \\
\texttt{0070 | 0000 0072 0000 000a 0099 0007 000a 0078 0006 000b 007b 008a 008a 007e 000b 0000} \\
\texttt{0080 | 0081 0000 008a 0084 0000 0000 0087 000e 000e 008a 0000 0000 008d 0000 000e 0090} \\
\texttt{0090 | 0000 0000 0093 000e ffff 0096 0000 0000 0069 0000 0000 ffff 000b 000b 009f 0006} \\
\texttt{00a0 | 000b 00a2 000a 000a 00a5 0006 000a 00a8 000a 0000 00ab 0000 000a 00ae 0000 0000} \\
\texttt{00b0 | 00b1 0006 000b 00b4 0000 000a 00ba 0000 0000 00a8 0009 000b 00bd 000b 0000 00c3} \\
\texttt{00c0 | 0000 0000 00c9 0000 0000 00c6 0000 000b 00cc 0000 0000 004e 002c 002c 00cf 002b} \\
\texttt{00d0 | 0000 00d2 0000 002c 00d5 0000 0000 00d8 002a 002a 00db 0029 0000 00de 0000 002a} \\
\texttt{00e0 | 00e1 0000 0000 00e4 0027 0027 00e7 0022 0000 00ea 0000 0027 00ed 0000 0000 00f0} \\
\texttt{00f0 | 000a 000a 00f3 0027 0000 00f6 0000 000a 00f9 0000 0000 00fc 0006 0027 00ff 010e} \\
\texttt{0100 | 010e 0102 000a 0000 0105 0000 010e 0108 0000 0000 010b 000b 000b 010e 0000 0000} \\
\texttt{0110 | 0111 0000 000b 0114 0000 0000 0117 000a 000a 011a 000b 0000 011d 0000 000a 0120} \\
\texttt{0120 | 0000 0000 0123 0004 000b 0126 000b 0000 012c 0000 0000 012f 0000 0000 013e 013d} \\
\texttt{0130 | 013d 0132 000a 0000 0135 0000 013d 0138 0000 0000 013b 0000 0000 013e 0006 002a} \\
\texttt{0140 | 0141 0165 0165 0144 002a 0000 0147 0000 0165 014a 0000 0000 014d 0166 0166 0150} \\
\texttt{0150 | 002a 0000 0153 0000 0166 0156 0000 0000 0159 016c 016c 015c 002a 0000 015f 0000} \\
\texttt{0160 | 016c 0162 0000 0000 0165 0000 0000 0168 0027 0000 016b 0000 0000 016e 0000 0000} \\
\texttt{0170 | 0171 0027 0027 0174 000a 0000 0177 0000 0027 017a 0000 0000 017d 0000 0000 00f0} \\
\texttt{0180 | 0000 0000 ffff 000a 000a 0186 0028 0000 0189 0000 000a 018c 0000 0000 018f 019e} \\
\texttt{0190 | 019e 0192 002c 0000 0195 0000 019e 0198 0000 0000 019b 0028 0028 019e 0000 0000} \\
\texttt{01a0 | 01a1 0000 0028 01a4 0000 0000 01a7 01cb 01cb 01aa 002c 0000 01ad 0000 01cb 01b0} \\
\texttt{01b0 | 0000 0000 01b3 01cc 01cc 01b6 002c 0000 01b9 0000 01cc 01bc 0000 0000 01bf 01d2} \\
\texttt{01c0 | 01d2 01c2 002c 0000 01c5 0000 01d2 01c8 0000 0000 01cb 0000 0000 01ce 000a 0000} \\
\texttt{01d0 | 01d1 0000 0000 01d4 0000 0000 01d7 0000 0000 00f0 0007 002c 01dd 0201 0201 01e0} \\
\texttt{01e0 | 002c 0000 01e3 0000 0201 01e6 0000 0000 01e9 0202 0202 01ec 002c 0000 01ef 0000} \\
\texttt{01f0 | 0202 01f2 0000 0000 01f5 0208 0208 01f8 002c 0000 01fb 0000 0208 01fe 0000 0000} \\
\texttt{0200 | 0201 0000 0000 0204 0028 0000 0207 0000 0000 020a 0000 0000 020d 0000 0000 00f0} \\
\texttt{0210 | 0007 002c 0213 0237 0237 0216 002c 0000 0219 0000 0237 021c 0000 0000 021f 0238} \\
\texttt{0220 | 0238 0222 002c 0000 0225 0000 0238 0228 0000 0000 022b 023e 023e 022e 002c 0000} \\
\texttt{0230 | 0231 0000 023e 0234 0000 0000 0237 0000 0000 023a 0028 0000 023d 0000 0000 0240} \\
\texttt{0240 | 0000 0000 0243 0252 0252 0246 002a 0000 0249 0000 0252 024c 0000 0000 024f 0028} \\
\texttt{0250 | 0028 0252 0000 0000 0255 0000 0028 0258 0000 0000 025b 0007 002a 025e 0000 0000} \\
\texttt{0260 | 00f0 0006 002a 0264 0288 0288 0267 002a 0000 026a 0000 0288 026d 0000 0000 0270} \\
\texttt{0270 | 0289 0289 0273 002a 0000 0276 0000 0289 0279 0000 0000 027c 028f 028f 027f 002a} \\
\texttt{0280 | 0000 0282 0000 028f 0285 0000 0000 0288 0000 0000 028b 0028 0000 028e 0000 0000} \\
\texttt{0290 | 0291 0000 0000 0294 02a3 02a3 0297 002c 0000 029a 0000 02a3 029d 0000 0000 02a0} \\
\texttt{02a0 | 0028 0028 02a3 0000 0000 02a6 0000 0028 02a9 0000 0000 02ac 0006 002c 02af 0000} \\
\texttt{02b0 | 0000 00f0 02c1 02c1 02b5 0028 0000 02b8 0000 02c1 02bb 0000 0000 02be 0028 0028} \\
\texttt{02c0 | 02c1 0000 0000 02c4 0000 0028 02c7 0000 0000 02ca 0000 0000 00f0 02dc 02dc 02d0} \\
\texttt{02d0 | 002c 0000 02d3 0000 02dc 02d6 0000 0000 02d9 000a 000a 02dc 0000 0000 02df 0000} \\
\texttt{02e0 | 000a 02e2 0000 0000 02e5 0309 0309 02e8 0028 0000 02eb 0000 0309 02ee 0000 0000} \\
\texttt{02f0 | 02f1 030a 030a 02f4 0028 0000 02f7 0000 030a 02fa 0000 0000 02fd 0310 0310 0300} \\
\texttt{0300 | 0028 0000 0303 0000 0310 0306 0000 0000 0309 0000 0000 030c 000a 0000 030f 0000} \\
\texttt{0310 | 0000 0312 0000 0000 0315 0006 002c 0318 0000 0000 0294 0028 ffff 031e 0000 0000} \\
\texttt{0320 | 0294 0330 0330 0324 002c 0000 0327 0000 0330 032a 0000 0000 032d 000a 000a 0330} \\
\texttt{0330 | 0000 0000 0333 0000 000a 0336 0000 0000 0339 0028 000a 033c 0028 0028 033f 000a} \\
\texttt{0340 | 0000 0342 0000 0028 0345 0000 0000 0348 0006 002c 034b 0000 0000 00f0 035d 035d} \\
\texttt{0350 | 0351 002c 0000 0354 0000 035d 0357 0000 0000 035a 000a 000a 035d 0000 0000 0360} \\
\texttt{0360 | 0000 000a 0363 0000 0000 0366 000a 0000 0369 0000 0028 036c 0000 0000 036f 0006} \\
\texttt{0370 | 002c 0372 0000 0000 00f0 0384 0384 0378 002a 0000 037b 0000 0384 037e 0000 0000} \\
\texttt{0380 | 0381 0027 0027 0384 0000 0000 0387 0000 0027 038a 0000 0000 038d 0007 002a 0390} \\
\texttt{0390 | 0000 0000 00f0 0007 002c 0396 03ba 03ba 0399 002c 0000 039c 0000 03ba 039f 0000} \\
\texttt{03a0 | 0000 03a2 03bb 03bb 03a5 002c 0000 03a8 0000 03bb 03ab 0000 0000 03ae 03c1 03c1} \\
\texttt{03b0 | 03b1 002c 0000 03b4 0000 03c1 03b7 0000 0000 03ba 0000 0000 03bd 0028 0000 03c0} \\
\texttt{03c0 | 0000 0000 03c3 0000 0000 03c6 03d5 03d5 03c9 002a 0000 03cc 0000 03d5 03cf 0000} \\
\texttt{03d0 | 0000 03d2 0028 0028 03d5 0000 0000 03d8 0000 0028 03db 0000 0000 03de 0000 0000} \\
\texttt{03e0 | 00f0 0007 002c 03e4 0408 0408 03e7 002c 0000 03ea 0000 0408 03ed 0000 0000 03f0} \\
\texttt{03f0 | 0409 0409 03f3 002c 0000 03f6 0000 0409 03f9 0000 0000 03fc 040f 040f 03ff 002c} \\
\texttt{0400 | 0000 0402 0000 040f 0405 0000 0000 0408 0000 0000 040b 0028 0000 040e 0000 0000} \\
\texttt{0410 | 0411 0000 0000 0414 0028 0028 0417 002a 0000 041a 0000 0028 041d 0000 0000 0420} \\
\texttt{0420 | 0000 0000 00f0 002a 002a 0426 0028 0000 0429 0000 002a 042c 0000 0000 042f 0000} \\
\texttt{0430 | 0000 0294 002c 002c 0435 0028 0000 0438 0000 002c 043b 0000 0000 043e 0000 0000} \\
\texttt{0440 | 00f0 000c 000c 0444 0028 0000 044a 0000 0000 0450 0000 0000 044d 0000 0028 0456} \\
\texttt{0450 | 000c 000c 0453 0007 000c 0456 0007 0028 0459 0000 0028 0462 000c 000c 045f 0007} \\
\texttt{0460 | 000c 0462 0471 0471 0465 002c 0000 0468 0000 0471 046b 0000 0000 046e 0028 0028} \\
\texttt{0470 | 0471 0000 0000 0474 0000 0028 0477 0000 0000 047a 0006 002c 047d 000c 0000 0483} \\
\texttt{0480 | 0000 0000 0489 0000 0000 0486 0000 000c 048f 0006 0027 048c 0000 0000 00f0 049e} \\
\texttt{0490 | 049e 0492 0027 0000 0495 0000 049e 0498 0000 0000 049b 0027 0027 049e 0000 0000} \\
\texttt{04a0 | 04a1 0000 0027 04a4 0000 0000 04a7 0000 0000 00f0 04b9 04b9 04ad 002a 0000 04b0} \\
\texttt{04b0 | 0000 04b9 04b3 0000 0000 04b6 000a 000a 04b9 0000 0000 04bc 0000 000a 04bf 0000} \\
\texttt{04c0 | 0000 04c2 000a 0000 04c8 0000 0000 04ce 0000 0000 04cb 0000 000a 0504 0007 000a} \\
\texttt{04d0 | 04d1 04f5 04f5 04d4 002a 0000 04d7 0000 04f5 04da 0000 0000 04dd 04f6 04f6 04e0} \\
\texttt{04e0 | 002a 0000 04e3 0000 04f6 04e6 0000 0000 04e9 04fc 04fc 04ec 002a 0000 04ef 0000} \\
\texttt{04f0 | 04fc 04f2 0000 0000 04f5 0000 0000 04f8 000a 0000 04fb 0000 0000 04fe 0000 0000} \\
\texttt{0500 | 0501 0000 0000 048f 0006 0027 0507 0007 002a 050a 0000 0000 00f0 000a 000a 0510} \\
\texttt{0510 | 0028 0000 0513 0000 000a 0516 0000 0000 0519 0028 0028 051c 0007 0028 051f 000a} \\
\texttt{0520 | 0000 0525 0000 0000 052b 0000 0000 0528 0000 000a 052e 0028 0028 052e 0007 000a} \\
\texttt{0530 | 0531 0000 000a 0537 0028 0028 0537 0000 0000 00f0 0000 0028 0546 0028 0028 0540} \\
\texttt{0540 | 0007 0028 0543 0000 0000 00f0 0028 0028 0549 0000 0000 00f0 000a 000a 054f 0028} \\
\texttt{0550 | 0000 0552 0000 000a 0555 0000 0000 0558 0028 0028 055b 000a 0000 0561 0000 0000} \\
\texttt{0560 | 0564 0000 0000 056a 0028 0028 0567 0007 0028 056a 0006 000a 056d 000a 0000 0573} \\
\texttt{0570 | 0000 0000 0576 0000 0000 057c 0028 0028 0579 0007 0028 057c 0000 0000 00f0 000a} \\
\texttt{0580 | 000a 0582 0009 0000 0585 0000 000a 0588 0000 0000 058b 0028 000a 058e 059d 059d} \\
\texttt{0590 | 0591 002c 0000 0594 0000 059d 0597 0000 0000 059a 0028 0028 059d 0000 0000 05a0} \\
\texttt{05a0 | 0000 0028 05a3 0000 0000 05a6 0006 002c 05a9 000b 000b 05ac 000a 0000 05b2 0000} \\
\texttt{05b0 | 0000 05b8 0000 0000 05b5 0000 000a 060f 000b 0000 05bb 0000 000b 05be 0000 0000} \\
\texttt{05c0 | 05c1 000c 000c 05c4 0028 0000 05c7 0000 000c 05ca 0000 0000 05cd 000d 000d 05d0} \\
\texttt{05d0 | 000c 0000 05d6 0000 0000 05d9 0000 0000 05df 000d 000d 05dc 0007 000d 05df 0006} \\
\texttt{05e0 | 000c 05e2 000c 0000 05e8 0000 0000 05eb 0000 0000 05f1 000d 000d 05ee 0007 000d} \\
\texttt{05f0 | 05f1 000d 0000 05f7 0000 0000 05fd 0000 0000 05fa 0000 000d 0600 0006 000b 0600} \\
\texttt{0600 | 0028 0000 0603 0000 0028 0606 0000 0000 0609 0007 000a 060c 0000 0000 05ac 0028} \\
\texttt{0610 | 0028 0612 000b 0000 0615 0000 0028 0618 0000 0000 061b 0000 0000 00f0 000a 000a} \\
\texttt{0620 | 0621 0009 0000 0624 0000 000a 0627 0000 0000 062a 000b 000b 062d 063c 063c 0630} \\
\texttt{0630 | 002c 0000 0633 0000 063c 0636 0000 0000 0639 000d 000d 063c 0000 0000 063f 0000} \\
\texttt{0640 | 000d 0642 0000 0000 0645 0006 002c 0648 0657 0657 064b 002c 0000 064e 0000 0657} \\
\texttt{0650 | 0651 0000 0000 0654 000e 000e 0657 0000 0000 065a 0000 000e 065d 0000 0000 0660} \\
\texttt{0660 | 0006 002c 0663 000a 0000 0669 0000 0000 066f 0000 0000 066c 0000 000a 0753 000b} \\
\texttt{0670 | 0000 0672 0000 000b 0675 0000 0000 0678 000f 000f 067b 0028 0000 067e 0000 000f} \\
\texttt{0680 | 0681 0000 0000 0684 0010 0010 0687 000f 0000 068d 0000 0000 0690 0000 0000 0696} \\
\texttt{0690 | 0010 0010 0693 0007 0010 0696 0006 000f 0699 000f 0000 069f 0000 0000 06a2 0000} \\
\texttt{06a0 | 0000 06a8 0010 0010 06a5 0007 0010 06a8 0010 0000 06ae 0000 0000 06b1 0000 0000} \\
\texttt{06b0 | 06ea 0011 0011 06b4 000e 0000 06b7 0000 0011 06ba 0000 0000 06bd 000f 000f 06c0} \\
\texttt{06c0 | 0011 0000 06c6 0000 0000 06c9 0000 0000 06cf 000f 000f 06cc 0006 000f 06cf 0006} \\
\texttt{06d0 | 0011 06d2 0011 0000 06d8 0000 0000 06db 0000 0000 06e1 000f 000f 06de 0006 000f} \\
\texttt{06e0 | 06e1 000f 0000 06e4 0000 000b 06e7 0000 0000 06ea 0006 0010 06ed 0010 0000 06f3} \\
\texttt{06f0 | 0000 0000 06f9 0000 0000 06f6 0000 0010 0732 0011 0011 06fc 000d 0000 06ff 0000} \\
\texttt{0700 | 0011 0702 0000 0000 0705 000f 000f 0708 0011 0000 070e 0000 0000 0711 0000 0000} \\
\texttt{0710 | 0717 000f 000f 0714 0006 000f 0717 0006 0011 071a 0011 0000 0720 0000 0000 0723} \\
\texttt{0720 | 0000 0000 0729 000f 000f 0726 0006 000f 0729 000f 0000 072c 0000 000b 072f 0000} \\
\texttt{0730 | 0000 0732 0028 0000 0735 0000 0028 0738 0000 0000 073b 000d 0000 073e 0000 000d} \\
\texttt{0740 | 0741 0000 0000 0744 000e 0000 0747 0000 000e 074a 0000 0000 074d 0007 000a 0750} \\
\texttt{0750 | 0000 0000 0663 0028 0028 0756 000b 0000 0759 0000 0028 075c 0000 0000 075f 0000} \\
\texttt{0760 | 0000 00f0 0771 0771 0765 002c 0000 0768 0000 0771 076b 0000 0000 076e 000a 000a} \\
\texttt{0770 | 0771 0000 0000 0774 0000 000a 0777 0000 0000 077a 000c 000c 077d 000b 000b 0780} \\
\texttt{0780 | 0006 000b 0783 000a 0000 0789 0000 0000 078c 0000 0000 078f 000b 000b 078f 000b} \\
\texttt{0790 | 0000 0795 0000 0000 079b 0000 0000 0798 0000 000b 07a4 0006 000c 079e 0028 000a} \\
\texttt{07a0 | 07a1 0000 0000 077d 0028 0000 07a7 0000 000a 07aa 0000 0000 07ad 0007 000c 07b0} \\
\texttt{07b0 | 0028 0028 07b3 000c 0000 07b6 0000 0028 07b9 0000 0000 07bc 07e0 07e0 07bf 002c} \\
\texttt{07c0 | 0000 07c2 0000 07e0 07c5 0000 0000 07c8 07e1 07e1 07cb 002c 0000 07ce 0000 07e1} \\
\texttt{07d0 | 07d1 0000 0000 07d4 07e7 07e7 07d7 002c 0000 07da 0000 07e7 07dd 0000 0000 07e0} \\
\texttt{07e0 | 0000 0000 07e3 000a 0000 07e6 0000 0000 07e9 0000 0000 07ec 0000 0000 00f0 0025} \\
\texttt{07f0 | 0000 07f5 0000 0000 07fb 0000 0000 07f8 0000 0025 07fe 0000 0000 00f0 080d 080d} \\
\texttt{0800 | 0801 0013 0000 0804 0000 080d 0807 0000 0000 080a 000a 000a 080d 0000 0000 0810} \\
\texttt{0810 | 0000 000a 0813 0000 0000 0816 000a 0000 081c 0000 0000 0822 0000 0000 081f 0000} \\
\texttt{0820 | 000a 09a5 0006 0024 0825 000c 000c 0828 0013 0000 082b 0000 000c 082e 0000 0000} \\
\texttt{0830 | 0831 0006 000c 0834 0858 0858 0837 000c 0000 083a 0000 0858 083d 0000 0000 0840} \\
\texttt{0840 | 0859 0859 0843 000c 0000 0846 0000 0859 0849 0000 0000 084c 085f 085f 084f 000c} \\
\texttt{0850 | 0000 0852 0000 085f 0855 0000 0000 0858 0000 0000 085b 0027 0000 085e 0000 0000} \\
\texttt{0860 | 0861 0000 0000 0864 0006 000c 0867 088b 088b 086a 000c 0000 086d 0000 088b 0870} \\
\texttt{0870 | 0000 0000 0873 088c 088c 0876 000c 0000 0879 0000 088c 087c 0000 0000 087f 0892} \\
\texttt{0880 | 0892 0882 000c 0000 0885 0000 0892 0888 0000 0000 088b 0000 0000 088e 0028 0000} \\
\texttt{0890 | 0891 0000 0000 0894 0000 0000 0897 0006 000c 089a 08be 08be 089d 000c 0000 08a0} \\
\texttt{08a0 | 0000 08be 08a3 0000 0000 08a6 08bf 08bf 08a9 000c 0000 08ac 0000 08bf 08af 0000} \\
\texttt{08b0 | 0000 08b2 08c5 08c5 08b5 000c 0000 08b8 0000 08c5 08bb 0000 0000 08be 0000 0000} \\
\texttt{08c0 | 08c1 002a 0000 08c4 0000 0000 08c7 0000 0000 08ca 0006 000c 08cd 08f1 08f1 08d0} \\
\texttt{08d0 | 000c 0000 08d3 0000 08f1 08d6 0000 0000 08d9 08f2 08f2 08dc 000c 0000 08df 0000} \\
\texttt{08e0 | 08f2 08e2 0000 0000 08e5 08f8 08f8 08e8 000c 0000 08eb 0000 08f8 08ee 0000 0000} \\
\texttt{08f0 | 08f1 0000 0000 08f4 002c 0000 08f7 0000 0000 08fa 0000 0000 08fd 0006 000c 0900} \\
\texttt{0900 | 0029 0029 0903 000a 0000 0906 0000 0029 0909 0000 0000 090c 0005 0000 090f 0000} \\
\texttt{0910 | 0029 0912 0000 0000 0915 002b 002b 0918 0029 0000 091b 0000 002b 091e 0000 0000} \\
\texttt{0920 | 0921 0005 0000 0924 0000 002b 0927 0000 0000 092a 0013 0013 092d 000a 0000 0930} \\
\texttt{0930 | 0000 0013 0933 0000 0000 0936 0006 000a 0939 0948 0948 093c 000a 0000 093f 0000} \\
\texttt{0940 | 0948 0942 0000 0000 0945 0027 0027 0948 0000 0000 094b 0000 0027 094e 0000 0000} \\
\texttt{0950 | 0951 0006 000a 0954 0963 0963 0957 000a 0000 095a 0000 0963 095d 0000 0000 0960} \\
\texttt{0960 | 0028 0028 0963 0000 0000 0966 0000 0028 0969 0000 0000 096c 0006 000a 096f 097e} \\
\texttt{0970 | 097e 0972 000a 0000 0975 0000 097e 0978 0000 0000 097b 002a 002a 097e 0000 0000} \\
\texttt{0980 | 0981 0000 002a 0984 0000 0000 0987 0006 000a 098a 0999 0999 098d 000a 0000 0990} \\
\texttt{0990 | 0000 0999 0993 0000 0000 0996 002c 002c 0999 0000 0000 099c 0000 002c 099f 0000} \\
\texttt{09a0 | 0000 09a2 0006 000a 09a5 0000 0000 00f0 0000 2b01 034e 0375 1350 2d01 0321 0375} \\
\texttt{09b0 | 1358 6203 6579 0180 0375 1360 6403 7075 01da 0375 136a 6404 6f72 0070 0294 0375} \\
\texttt{09c0 | 1374 7304 6177 0070 0183 0375 1380 7206 6873 6669 0074 057f 0375 0000 5b03 5d40} \\
\texttt{09d0 | 02b2 0375 139a 5b03 5d21 02cd 0375 138c 7303 2170 0432 0375 13ae 3002 003d 050d} \\
\texttt{09e0 | 0375 13b8 3002 003c 054c 0375 13c2 3002 003e 053a 0375 13a4 6d03 7875 061e 0375} \\
\texttt{09f0 | 13d6 7005 7561 6573 07ef 0375 13cc 3202 002a 01da 034e 0375 13e0 2827 6f63 736e} \\
\texttt{0a00 | 2974 0210 02b2 0375 13f8 2302 0030 0a01 0000 1408 2302 0031 0a01 0001 1412 2303} \\
\texttt{0a10 | 312d 0a01 ffff 141c 2302 0032 0a01 0002 13ec 3102 002b 0a0c 034e 0375 1430 3102} \\
\texttt{0a20 | 002d 0a0c 0321 0375 1426 2806 7570 6873 0029 0210 01da 02b2 0183 0a1b 0261 0375} \\
\texttt{0a30 | 1448 2824 7075 0029 0210 01da 02b2 0a29 0013 02b2 034e 09f9 0183 0a1b 0261 0375} \\
\texttt{0a40 | 1460 2825 6176 2972 0210 09f9 0375 1480 2826 7375 7265 0029 0210 02b2 0a29 0013} \\
\texttt{0a50 | 02b2 034e 09f9 0375 143c 2941 0375 14a8 6f04 6576 0072 0183 01da 0261 0183 0210} \\
\texttt{0a60 | 0375 14ae 6906 766e 7265 0074 0a07 0183 0321 0a21 0375 14c2 7803 726f 0261 01da} \\
\texttt{0a70 | 0a66 0183 0210 061e 0375 14d6 6f02 0072 0a5b 061e 0375 14ea 6103 646e 0a07 0183} \\
\texttt{0a80 | 061e 0375 14f6 3202 002f 0a0c 057f 0375 1504 4001 0a85 02b2 0375 1510 2101 0a85} \\
\texttt{0a90 | 02cd 0375 148e 4002 002b 01da 0a8a 0375 151a 3c04 6b6f 003e 0a4c 0012 1524 3c06} \\
\texttt{0aa0 | 6d65 7469 003e 0a4c 0014 153c 3c05 656b 3e79 0a4c 0016 154a 3c06 6365 6f68 003e} \\
\texttt{0ab0 | 0a4c 0018 1556 3c09 696c 6574 6172 3e6c 0a4c 001a 1564 3c05 6174 3e70 0a4c 001c} \\
\texttt{0ac0 | 1574 3c08 7865 6570 7463 003e 0a4c 001e 1580 3c07 7265 6f72 3e72 0a4c 0020 1590} \\
\texttt{0ad0 | 3c06 6f63 646c 003e 0a29 0044 0375 1530 6307 7275 6572 746e 0a29 003a 0375 15ae} \\
\texttt{0ae0 | 7208 6f6f 2d74 6f76 0063 0a29 0040 0375 15be 7404 6968 0073 0a34 0000 0375 15d0} \\
\texttt{0af0 | 7003 6461 0aec 0a29 03c0 034e 0375 15de 2305 6f76 7363 0a29 0008 0375 15ee 6307} \\
\texttt{0b00 | 6e6f 6574 7478 0a29 002a 0375 15fc 6203 6b6c 0a44 002f 160c 7303 7263 0a44 002f} \\
\texttt{0b10 | 1616 6204 7361 0065 0a4c 0022 1620 6403 6c70 0a4c 0024 162c 6803 646c 0a4c 0026} \\
\texttt{0b20 | 1636 7305 6174 6574 0a4c 0028 1640 3e03 6e69 0a4c 002a 164c 7304 6170 006e 0a4c} \\
\texttt{0b30 | 002c 1656 6202 006c 0a01 0020 159e 6802 003f 0a01 0024 166c 6306 6379 656c 0073} \\
\texttt{0b40 | 0a01 0048 1676 7302 0070 0a01 0058 1684 7505 6573 3f72 0a01 004c 168e 630b 6c61} \\
\texttt{0b50 | 6269 6172 6974 6e6f 0a44 0f00 169a 7205 6461 7869 0b14 0a8a 0375 1662 6804 7265} \\
\texttt{0b60 | 0065 0b39 0a8a 0375 16ba 7303 4070 0b45 0a8a 0a1b 0375 16c8 6803 7865 0a29 0010} \\
\texttt{0b70 | 0b14 0a8f 0375 16d6 6407 6365 6d69 6c61 0a29 000a 0b14 0a8f 0375 16e6 5d01 0a11} \\
\texttt{0b80 | 0b24 0a8f 0375 16fa 5b41 0a07 0b24 0a8f 0375 1706 6e03 7069 0183 0294 0375 1712} \\
\texttt{0b90 | 7404 6375 006b 0183 0a5b 0375 171e 3f04 7564 0070 01da 0441 0b9e 01da 0375 172c} \\
\texttt{0ba0 | 7203 746f 0261 0183 0210 0183 0375 173e 2d04 6f72 0074 0ba2 0ba2 0375 174e 3205} \\
\texttt{0bb0 | 7264 706f 0294 0294 0375 175c 3204 7564 0070 0a5b 0a5b 0375 16ac 7304 6568 0064} \\
\texttt{0bc0 | 0ba2 0294 0375 176a 3e01 0321 053a 0375 1786 3c01 0183 0bc5 0375 1790 3d01 0321} \\
\texttt{0bd0 | 050d 0375 179a 3c02 003e 0bcf 050d 0375 17a4 3003 3e3c 050d 050d 0375 17b0 3003} \\
\texttt{0be0 | 3d3c 053a 050d 0375 17bc 3003 3d3e 054c 050d 0375 17c8 3e02 003d 0bca 050d 0375} \\
\texttt{0bf0 | 17d4 3c02 003d 0bc5 050d 0375 17e0 7502 003c 0bb9 0be7 0183 0be7 0bd5 0261 0bca} \\
\texttt{0c00 | 0210 0bd5 0375 17ec 7502 003e 0183 0bf9 0375 1806 7503 3d3e 0bf9 050d 0375 1812} \\
\texttt{0c10 | 7503 3d3c 0c06 050d 0375 181e 7706 7469 6968 006e 0a5b 0321 0261 0321 0210 0bf9} \\
\texttt{0c20 | 0375 182a 6e06 6765 7461 0065 0a21 0a66 0375 1842 7303 643e 01da 054c 0375 1852} \\
\texttt{0c30 | 6103 7362 0c2c 0441 0c36 0c26 0375 185e 6304 6c65 006c 0a16 0375 186e 6305 6c65} \\
\texttt{0c40 | 2b6c 0c3b 034e 0375 187a 6305 6c65 736c 09f9 0375 1888 6507 6578 7563 6574 0a85} \\
\texttt{0c50 | 0261 0375 1778 4008 7865 6365 7475 0065 0a8a 0c4f 0375 1894 3f25 7865 7469 0441} \\
\texttt{0c60 | 0c62 038d 0375 18b6 6b04 7965 003f 0a11 02b2 0c26 0c2c 0441 0c79 0a29 0006 0a8a} \\
\texttt{0c70 | 0a29 0008 0a7e 0441 0c76 0180 0294 0a07 0375 0a11 0375 18c6 6b03 7965 07ef 0aa9} \\
\texttt{0c80 | 0c58 0441 0c7e 0375 18f6 6504 696d 0074 07ef 0aa3 0c58 0375 1908 6302 0072 0a29} \\
\texttt{0c90 | 000d 0c88 0a29 000a 0c88 0375 1918 670b 7465 632d 7275 6572 746e 0adc 0a8a 0375} \\
\texttt{0ca0 | 192c 730b 7465 632d 7275 6572 746e 0adc 0a8f 0375 18a4 6c04 7361 0074 0c9d 0a8a} \\
\texttt{0cb0 | 0375 1940 7004 6369 006b 0b67 034e 02b2 0375 1962 2b02 0021 0a85 0b93 02b2 034e} \\
\texttt{0cc0 | 0183 02cd 0375 1972 6c06 6873 6669 0074 0b9a 0441 0cd1 0a21 0183 09f9 0183 048f} \\
\texttt{0cd0 | 0cc8 0375 1986 6302 0040 0a95 0183 0a0c 0a7e 0441 0cdf 0a29 0008 057f 0375 0a29} \\
\texttt{0ce0 | 00ff 0a7e 0375 19a4 6302 0021 0183 0a29 00ff 0a7e 01da 0a29 0008 0cc8 0a78 0183} \\
\texttt{0cf0 | 0b93 0a95 0183 0a0c 0a7e 050d 0a29 00ff 0a6e 0261 0a5b 0a6e 0210 0a7e 0a6e 0183} \\
\texttt{0d00 | 0a8f 0375 1954 6303 2b40 01da 0cd5 0375 19c6 6d03 7861 0bb9 0bc5 061e 0375 1a10} \\
\texttt{0d10 | 6d03 6e69 0bb9 0bca 061e 0375 1a1e 7309 756f 6372 2d65 6469 0a34 0010 0a8a 0375} \\
\texttt{0d20 | 1a2c 3202 0021 0b93 0a8f 0c41 0a8f 0375 1a40 3202 0040 01da 0c41 0a8a 0183 0a8a} \\
\texttt{0d30 | 0375 1a50 3223 723e 0210 0183 0261 0183 0261 0261 0375 1a62 3223 3e72 0210 0210} \\
\texttt{0d40 | 0183 0210 0183 0261 0375 1a04 7403 7075 0a4c 002e 0000 1a76 7306 756f 6372 0065} \\
\texttt{0d50 | 0d48 0d2b 0375 1a96 6107 696c 6e67 6465 01da 0a0c 0a7e 0bdb 0a0c 0a7e 034e 0375} \\
\texttt{0d60 | 1aa6 6105 696c 6e67 0b61 0d58 0b39 0a8f 0375 1ac0 6105 6c6c 746f 0b39 0cbc 0375} \\
\texttt{0d70 | 1ad2 2c01 0d64 0b61 0a8f 0c3b 0d6d 0375 1ae0 6305 756f 746e 01da 0a1b 0183 0cd5} \\
\texttt{0d80 | 0375 1af0 2b07 7473 6972 676e 0a0c 0a5b 0d12 0ba2 0a5b 034e 0bab 0321 0375 1b02} \\
\texttt{0d90 | 7404 7079 0065 01da 0441 0d9d 0183 0d7c 0c88 0183 0a21 048f 0d93 0bb2 0375 1b1e} \\
\texttt{0da0 | 6305 6f6d 6576 0261 048f 0dad 0261 0d05 0393 0ce6 0a1b 0210 0a1b 04aa 0da6 0bb2} \\
\texttt{0db0 | 0375 1b3e 6604 6c69 006c 0183 0261 0183 048f 0dbd 0bb9 0ce6 0a1b 04aa 0dba 0bb2} \\
\texttt{0dc0 | 0375 1b62 6505 6172 6573 0a07 0db5 0375 1a8a 6403 246f 0d3e 09f9 01da 0d7c 034e} \\
\texttt{0dd0 | 0d58 0a85 0261 0183 0261 0375 1b90 2803 2924 0dcb 0375 1bac 2e02 0024 0dcb 0d7c} \\
\texttt{0de0 | 0d93 0375 1b82 7305 6170 6563 0b34 0c88 0375 1bc4 6305 7461 6863 0b67 0261 0a34} \\
\texttt{0df0 | 000a 0a8a 0261 03e1 0a34 000a 0a8f 0c4f 0210 0a34 000a 0a8f 038d 0a07 0375 1bd2} \\
\texttt{0e00 | 7405 7268 776f 0b9a 0441 0e14 0a34 000a 0a8a 0423 0210 0a34 000a 0a8f 0210 0183} \\
\texttt{0e10 | 0261 0432 0294 0210 0375 1bfe 6105 6f62 7472 0a11 0e03 0375 1bb6 2807 6261 726f} \\
\texttt{0e20 | 2974 0dcb 0183 0441 0e28 0d7c 0d93 0e19 0294 0375 1c38 6405 7065 6874 0a29 0056} \\
\texttt{0e30 | 0a8a 0b67 0321 0a21 0375 1c54 3f06 6564 7470 0068 0e2e 0bed 0a29 fffc 0a7e 0e03} \\
\texttt{0e40 | 0375 1c2a 7503 2b6d 0bb9 034e 0261 0393 0be7 0261 0bb9 0a7e 054c 0210 0a78 0261} \\
\texttt{0e50 | 0a78 054c 0210 0a7e 0c26 0210 0183 0375 1c82 6407 656e 6167 6574 0a66 0261 0a66} \\
\texttt{0e60 | 0a0c 0e44 0210 034e 0375 1cb0 6402 002b 0261 0183 0261 0e44 0210 034e 0210 034e} \\
\texttt{0e70 | 0375 1cca 7503 2a6d 0a07 0183 0a29 000f 0261 01da 0e44 0261 0261 01da 0e44 0210} \\
\texttt{0e80 | 034e 0210 0441 0e89 0261 0a5b 0e44 0210 034e 04aa 0e79 0bc0 0375 1ce2 2a01 0e74} \\
\texttt{0e90 | 0294 0375 1d1a 7506 2f6d 6f6d 0064 0b9a 050d 0a29 fff6 0a7e 0e03 0bb9 0bf9 0441} \\
\texttt{0ea0 | 0ec8 0c26 0a29 000f 0261 0261 01da 0e44 0261 0261 01da 0e44 0210 034e 01da 0210} \\
\texttt{0eb0 | 0393 0183 0261 0e44 0210 0bdb 0183 0bdb 034e 0441 0ec1 0261 0294 0a1b 0210 048f} \\
\texttt{0ec0 | 0ec2 0294 0210 04aa 0ea5 0294 0183 0375 0bb2 0294 0a11 01da 0375 1d24 6d05 6d2f} \\
\texttt{0ed0 | 646f 0c2c 01da 0261 0441 0eda 0c26 0261 0e5d 0210 0261 0c2c 0441 0ee0 0393 034e} \\
\texttt{0ee0 | 0210 0e97 0210 0441 0ee8 0183 0c26 0183 0375 1d9a 2f04 6f6d 0064 0a5b 054c 0183} \\
\texttt{0ef0 | 0ed1 0375 1dd2 6d03 646f 0eed 0294 0375 1de4 2f01 0eed 0b8c 0375 1c6a 2806 6d65} \\
\texttt{0f00 | 7469 0029 031b 0375 1df0 6504 6863 006f 0ab0 0c58 0375 1dfa 7403 7061 01da 0f08} \\
\texttt{0f10 | 0a5b 0ce6 0a1b 0375 1e16 6b04 6174 0070 01da 01da 0a29 000d 0bd5 0261 0a29 000a} \\
\texttt{0f20 | 0bd5 0210 0a7e 0441 0f45 01da 0a29 0008 0bd5 0261 0a29 007f 0bd5 0210 0a7e 0441} \\
\texttt{0f30 | 0f34 0b34 0f0e 0375 0261 0a5b 0393 0bca 01da 0441 0f42 0a29 0008 01da 0f08 0b34} \\
\texttt{0f40 | 0f08 0f08 0210 034e 0375 0294 0b8c 01da 0375 1e08 6106 6363 7065 0074 0a5b 034e} \\
\texttt{0f50 | 0a5b 0bb9 0bd5 0441 0f65 0c7e 01da 0b34 0321 0a29 005f 0bf9 0441 0f61 0f0e 048f} \\
\texttt{0f60 | 0f63 0abe 0c58 048f 0f51 0294 0a5b 0321 0375 1e92 6506 7078 6365 0074 0ac6 0c58} \\
\texttt{0f70 | 0b2f 0a8f 0294 0375 1ed2 7403 6269 0d50 0294 0375 1ee8 7105 6575 7972 0f77 0a29} \\
\texttt{0f80 | 0100 0ac6 0c58 0d48 0a8f 0294 0a07 0b29 0a8f 0375 1ef4 2d09 7274 6961 696c 676e} \\
\texttt{0f90 | 0261 048f 0f9e 0b34 0a5b 0393 034e 0cd5 0bca 0441 0f9e 0210 0a1b 0375 04aa 0f93} \\
\texttt{0fa0 | 0a07 0375 1e28 6c04 6f6f 006b 0183 0261 0bab 01da 0441 0fbf 0a5b 0cd5 0393 0321} \\
\texttt{0fb0 | 0393 0b34 0bcf 0a29 0004 0cb5 0c4f 0441 0fbc 038d 0bc0 0375 0d86 048f 0fa9 038d} \\
\texttt{0fc0 | 0bc0 0375 1f44 7507 6d6e 7461 6863 0441 0fcb 053a 0375 0bdb 0375 1f84 6d05 7461} \\
\texttt{0fd0 | 6863 0fc7 0a66 0375 1f14 7005 7261 6573 0261 0f77 0b29 0a8a 034e 0d48 0a8a 0b29} \\
\texttt{0fe0 | 0a8a 0321 0393 0261 0a5b 0210 0183 0d34 0393 0a29 1f8e 0fa6 0bb9 0210 0a29 1fa2} \\
\texttt{0ff0 | 0fa6 0183 0210 0321 0261 0321 0210 0a1b 0b29 0cbc 0210 0b34 0bcf 0441 1000 0f90} \\
\texttt{1000 | 0a07 0d0b 0375 1f9a 6206 6e61 656e 0072 0261 01da 053a 0441 1012 0393 0c88 0a21} \\
\texttt{1010 | 048f 1009 0294 038d 0375 1fa8 6804 6c6f 0064 0a11 0b1e 0cbc 0b1e 0a8a 0ce6 0375} \\
\texttt{1020 | 202a 2302 003e 0bb2 0b1e 0a8a 0aec 0a29 0380 034e 0a5b 0321 0375 2006 6507 7478} \\
\texttt{1030 | 6172 7463 01da 0261 0e97 0210 0183 0261 0e97 0210 0ba2 0375 205a 6405 6769 7469} \\
\texttt{1040 | 0a29 0009 0a5b 0bca 0a29 0007 0a7e 034e 0a29 0030 034e 0375 2040 2301 0a16 0e3a} \\
\texttt{1050 | 0a07 0b5a 1032 1040 1019 0375 2098 2302 0073 104e 0bb9 0a78 050d 0441 1059 0375} \\
\texttt{1060 | 20ac 3c02 0023 0aec 0a29 0380 034e 0b1e 0a8f 0375 20c0 7304 6769 006e 0be7 0c5f} \\
\texttt{1070 | 0a29 002d 1019 0375 20d4 7503 722e 0261 0a07 1063 1059 1023 0210 0a5b 0321 0b34} \\
\texttt{1080 | 1008 0d93 0375 20e8 7502 002e 0de6 0a07 1077 0375 2078 2803 292e 0c32 0b5a 0762} \\
\texttt{1090 | 0b9a 0441 1094 108d 1040 0c88 0375 2106 2e01 0de6 0c2c 0441 10a0 0a29 002d 0c88} \\
\texttt{10a0 | 108d 0375 212e 3e07 756e 626d 7265 0bb9 0d34 0294 0cd5 0b5a 0261 0a29 0030 0321} \\
\texttt{10b0 | 0a29 0009 0a5b 0bca 0441 10be 0a29 0007 0321 01da 0a29 000a 0bca 0a78 01da 0210} \\
\texttt{10c0 | 0bf9 050d 0441 10c7 0294 0d3e 0375 0183 0b5a 0e74 0294 0ba2 0b5a 0e74 0e68 0d3e} \\
\texttt{10d0 | 0d86 01da 050d 0441 10a7 0375 2144 6e07 6d75 6562 3f72 0a11 0b19 0a8f 0b5a 0261} \\
\texttt{10e0 | 0a5b 0cd5 0a29 002d 0bcf 01da 0261 0441 10ea 0d86 0a5b 0cd5 0a29 0024 0bcf 0441} \\
\texttt{10f0 | 10f3 0b6e 0d86 0d34 0a07 01da 0d3e 10a7 01da 0441 1113 0a5b 0cd5 0a29 002e 0bd5} \\
\texttt{1100 | 0441 110b 0bc0 0ba2 0210 0bb2 0a07 0210 0b14 0a8f 0375 0a21 0b19 0a8f 0a1b 0b19} \\
\texttt{1110 | 0a8a 048f 10f7 0bb2 0210 0441 1118 0e5d 0210 0b14 0a8f 0a11 0375 21ac 2e02 0073} \\
\texttt{1120 | 0e2e 0261 048f 1127 0393 0cb5 1099 04aa 1124 0375 223a 6307 6d6f 6170 6572 0ba2} \\
\texttt{1130 | 0a5b 0321 0b9a 0441 113a 0261 0bb2 0210 0b8c 0375 0261 048f 1149 0d7c 0ba2 0d7c} \\
\texttt{1140 | 0ba2 0321 0b9a 0441 1149 038d 0b8c 0b8c 0375 04aa 113d 0bb2 0a07 0375 2254 6e03} \\
\texttt{1150 | 6166 0c41 0375 229c 6303 6166 1151 0d05 0a29 001f 0a7e 034e 0c41 0c3b 0c26 0a7e} \\
\texttt{1160 | 0375 2114 2808 6573 7261 6863 0029 0183 0261 01da 01da 0441 118a 01da 1151 0d7c} \\
\texttt{1170 | 0a29 009f 0a7e 0393 0d7c 112f 050d 0441 1186 038d 01da 1151 0a29 0040 0183 0a8a} \\
\texttt{1180 | 0a7e 0bdb 0a0c 0a78 0c26 0375 0b8c 0a95 048f 116a 038d 0bb2 0a07 0375 22c2 2806} \\
\texttt{1190 | 6966 646e 0029 0261 0b03 0a95 0441 11a8 0a95 0a8a 0393 0183 1167 0b9a 0441 11a5} \\
\texttt{11a0 | 0261 0bc0 0210 038d 0375 0c41 048f 1195 0294 0a07 0210 0a07 0375 22a6 730f 6165} \\
\texttt{11b0 | 6372 2d68 6f77 6472 696c 7473 1167 0bc0 0375 235a 6604 6e69 0064 1193 0bc0 0375} \\
\texttt{11c0 | 2372 6327 6d6f 6970 656c 0210 01da 02b2 0d72 0a1b 0261 0375 231c 2809 696c 6574} \\
\texttt{11d0 | 6172 296c 0b24 0a8a 0441 11d9 11c5 0a29 0d72 0375 2380 6c47 7469 7265 6c61 0ab8} \\
\texttt{11e0 | 0c58 0375 23b4 6308 6d6f 6970 656c 002c 0d64 0a85 0d72 0375 2398 3f06 6f66 6e75} \\
\texttt{11f0 | 0064 0c5f 0de6 0d7c 0d93 0a29 003f 0c88 0c8f 0a29 fff3 0e03 0375 23c4 6909 746e} \\
\texttt{1200 | 7265 7270 7465 11bd 0b9a 0441 1223 0b24 0a8a 0441 1214 053a 0441 1211 1156 0c4f} \\
\texttt{1210 | 0375 1156 11e8 0375 0294 01da 1151 0cd5 0a29 0020 0a7e 0bdb 0a29 fff2 0a7e 0e03} \\
\texttt{1220 | 1156 0c4f 0375 01da 0261 0d7c 10db 0441 123a 038d 0b19 0a8a 054c 0441 1232 0294} \\
\texttt{1230 | 048f 1238 0b24 0a8a 0441 1237 0183 11df 11df 0375 0210 0a07 11f1 0375 23fa 6709} \\
\texttt{1240 | 7465 6f2d 6472 7265 0b03 0a07 0261 0a95 0393 0a6e 0441 124f 0c41 048f 1247 038d} \\
\texttt{1250 | 01da 0c3b 0321 0183 0b03 0321 0a85 01da 0261 0a21 0c2c 0a29 ffce 0a7e 0e03 0261} \\
\texttt{1260 | 048f 1266 0a95 0183 0c3b 0321 04aa 1262 0a8a 0210 0375 0000 7309 7465 6f2d 6472} \\
\texttt{1270 | 7265 01da 0a11 0bcf 0441 127b 0294 0ae5 0a0c 1271 0375 01da 0afb 0bc5 0a29 ffcf} \\
\texttt{1280 | 0a7e 0e03 0b03 0183 0261 048f 128a 0b93 0a8f 0c41 04aa 1287 0a07 0183 0a8f 0375} \\
\texttt{1290 | 247c 2807 726f 6564 2972 01da 0441 12a6 0a21 0183 0261 1295 0a5b 0393 0a6e 0441} \\
\texttt{12a0 | 12a5 0a1b 0210 0bab 0375 038d 0375 2520 2d06 726f 6564 0072 1244 1295 0b8c 1271} \\
\texttt{12b0 | 0375 254e 2b06 726f 6564 0072 01da 0261 12ac 1244 0210 0183 0a1b 1271 0375 24d6} \\
\texttt{12c0 | 660e 726f 6874 772d 726f 6c64 7369 0074 0a01 003c 257e 7306 7379 6574 006d 0a01} \\
\texttt{12d0 | 0042 2594 6605 726f 6874 0ae5 12c8 0a16 1271 0375 25a2 6f04 6c6e 0079 0a11 1271} \\
\texttt{12e0 | 0375 23d8 2e03 6469 1151 0d7c 0a29 001f 0a7e 0d93 0de6 0375 25b4 7705 726f 7364} \\
\texttt{12f0 | 0c8f 1244 0b9a 0441 130b 0183 0a8a 0b9a 0441 1308 01da 1151 0cd5 0a29 0080 0a7e} \\
\texttt{1300 | 050d 0441 1305 01da 12e4 0a8a 048f 12f7 0a21 048f 12f2 0375 2562 640b 6665 6e69} \\
\texttt{1310 | 7469 6f69 736e 0b03 0a8a 0ca7 0375 2618 7704 726f 0064 0a0c 0e3a 0fd8 0b61 0d58} \\
\texttt{1320 | 01da 0261 0bb9 0a8f 0a1b 0183 0da3 0210 0375 25c2 7405 6b6f 6e65 0b34 131b 0375} \\
\texttt{1330 | 2652 3f07 6e75 7169 6575 01da 0c9d 1167 050d 0c5f 0de6 0bb2 0a29 0046 0a8a 12e4} \\
\texttt{1340 | 0dde 7209 6465 6665 6e69 6465 0c8f 0375 2660 3f04 756e 006c 0d05 0c5f 0a29 fff0} \\
\texttt{1350 | 0e03 0375 2690 3f04 656c 006e 0d05 0a29 001f 0bc5 0a29 ffed 0a7e 0e03 0375 262e} \\
\texttt{1360 | 6304 6168 0072 132d 134c 0d7c 0294 0cd5 0375 26be 5b46 6863 7261 005d 1363 11c5} \\
\texttt{1370 | 0a29 0d72 0375 26d2 3b61 0a29 cafe 0bd5 0a29 ffea 0a7e 0e03 0a29 0375 0d72 0b85} \\
\texttt{1380 | 0b9a 0441 1385 0c9d 0a8f 0375 26e6 3a01 0d64 0b61 01da 0a29 0046 0a8f 0cae 0d72} \\
\texttt{1390 | 132d 134c 1356 1335 0d7c 034e 0b39 0a8f 0d64 0a29 cafe 0b7f 0375 270c 3a07 6f6e} \\
\texttt{13a0 | 616e 656d 0d64 0b61 0a07 0a29 cafe 0b7f 0375 273a 2741 132d 11bd 11f1 1156 11df} \\
\texttt{13b0 | 0375 2752 7267 6365 7275 6573 0a29 0046 0a8a 1156 11e8 0375 26a4 7406 676f 6c67} \\
\texttt{13c0 | 0065 0b93 0a8a 0a6e 0183 0a8f 0375 2778 6804 6469 0065 132d 11bd 11f1 1151 0a29} \\
\texttt{13d0 | 0080 0183 13c1 0375 278e 6d24 7261 006b 0b61 0a07 0d72 0375 2762 6265 6765 6e69} \\
\texttt{13e0 | 0b61 0375 27b8 6962 0066 0a29 0441 0d72 13d8 0375 27c4 7565 746e 6c69 0a85 13e5} \\
\texttt{13f0 | 0a8f 0375 27d4 6165 6167 6e69 0a29 048f 0d72 11e8 0375 27e4 7464 6568 006e 0b61} \\
\texttt{1400 | 0a85 0183 0a8f 0375 27f6 7765 6968 656c 13e5 0375 2808 7266 7065 6165 0074 0183} \\
\texttt{1410 | 13f6 13ff 0375 2814 6564 736c 0065 0a29 048f 0d72 13d8 0183 13ff 0375 2826 6663} \\
\texttt{1420 | 726f 0a29 0261 0d72 0b61 0375 283c 6163 7466 0294 0a29 048f 0d72 13d8 0b61 0183} \\
\texttt{1430 | 0375 284c 6e64 7865 0074 0a29 04aa 0d72 11e8 0375 27a8 2828 616d 6b72 7265 0029} \\
\texttt{1440 | 0210 09f9 0a95 0b39 0a8f 0c41 0a8a 0c9d 0a8f 0375 2862 6306 6572 7461 0065 1388} \\
\texttt{1450 | 0294 0b85 11c5 0a44 0c9d 0a8f 0375 2894 7608 7261 6169 6c62 0065 144f 0a07 0d72} \\
\texttt{1460 | 0375 28ae 6308 6e6f 7473 6e61 0074 144f 0c3b 0c26 0d6d 11c5 0a01 0d72 0375 28c2} \\
\texttt{1470 | 7504 6573 0072 144f 0c3b 0c26 0d6d 11c5 0a4c 0b4b 0a8a 0d72 0a0c 0b4b 0cbc 0375} \\
\texttt{1480 | 28de 3e05 6f62 7964 0c41 0375 2874 2826 6f64 7365 0029 0210 0210 09f9 0183 0261} \\
\texttt{1490 | 0375 290c 2826 6f63 706d 0029 0210 0a29 0046 0a8a 1156 0a95 0a29 0a44 0bd5 0a29} \\
\texttt{14a0 | ffe1 0a7e 0e03 0a8f 0375 2900 6465 656f 3e73 11c5 1496 11c5 148b 0375 294a 6d06} \\
\texttt{14b0 | 7261 656b 0072 0cae 0d64 0b61 144f 0c3b 0c26 0d6d 11c5 1440 0d72 0d72 0375 295c} \\
\texttt{14c0 | 7263 2170 11c5 0423 0375 297e 7263 4070 11c5 03e1 0375 298a 3e62 0072 11c5 0261} \\
\texttt{14d0 | 0375 2996 7262 003e 11c5 0210 0375 29a2 7262 0040 11c5 0393 0375 29ae 7265 7264} \\
\texttt{14e0 | 706f 11c5 038d 0375 29ba 6564 6978 0074 11c5 0375 0375 2922 2803 2973 0d64 0a29} \\
\texttt{14f0 | 0022 131b 0d7c 0b8c 0a1b 0d6d 0d64 0375 29c8 2e62 0022 11c5 0dde 14ee 0375 29f0} \\
\texttt{1500 | 2462 0022 11c5 0dd9 14ee 0375 29fe 6166 6f62 7472 0022 11c5 0e21 14ee 0375 2a0c} \\
\texttt{1510 | 2841 0a29 0029 0fd8 0bb2 0375 2a1e 2e42 0028 0a29 0029 0fd8 0d93 0375 2a2c 5c41} \\
\texttt{1520 | 0f77 0a8a 0b29 0a8f 0375 2a3c 7048 736f 7074 6e6f 0065 132d 11bd 11f1 1156 11e8} \\
\texttt{1530 | 0375 29d6 2805 666e 2961 0cae 1151 13c1 0375 2a4a 6909 6d6d 6465 6169 6574 0a29} \\
\texttt{1540 | 0040 1535 0375 2a72 630c 6d6f 6970 656c 6f2d 6c6e 0079 0a29 0020 1535 0375 2a86} \\
\texttt{1550 | 7303 6565 132d 11bd 11f1 0c8f 0a95 0a29 0375 0bd5 0441 1568 0a95 1099 0c41 0b61} \\
\texttt{1560 | 0a5b 0bca 0441 1566 0294 0375 048f 1556 0a8a 1086 0375 2a9e 6404 6d75 0070 0d58} \\
\texttt{1570 | 0b9a 0441 157c 0183 0a95 1099 0c41 0183 0c3b 0321 048f 1570 0294 0375 2a62 6305} \\
\texttt{1580 | 736b 6d75 0d58 01da 0a29 c0de 0321 0261 0b9a 0441 1596 0183 0a95 0210 034e 0261} \\
\texttt{1590 | 0c41 0183 0c3b 0321 048f 1588 0294 0210 0375 2ad6 6407 6665 6e69 6465 132d 11bd} \\
\texttt{15a0 | 0b8c 0bdb 0375 2b32 5b46 6874 6e65 005d 0375 2b46 5b46 6c65 6573 005d 132d 0d05} \\
\texttt{15b0 | 0441 15c1 11bd 0294 1156 01da 0a29 2b5c 0bcf 0183 0a29 2b50 0bcf 0a78 0c5f 048f} \\
\texttt{15c0 | 15ae 0f7e 0294 048f 15ae 0375 2b52 5b44 6669 005d 0c5f 15ae 0375 2b8c 6d02 0073} \\
\texttt{15d0 | 0261 07ef 0b54 0a8a 0261 04aa 15d5 04aa 15d1 0375 2b9a 6204 6c65 006c 0a29 0007} \\
\texttt{15e0 | 0c88 0375 2afc 6303 6973 0a29 001b 0c88 0a29 005b 0c88 0375 2bb4 7004 6761 0065} \\
\texttt{15f0 | 15e5 0dde 3202 004a 15e5 0dde 3104 313b 0048 0375 2bd8 6105 2d74 7978 0b5a 0b78} \\
\texttt{1600 | 0261 15e5 0a07 1077 0dde 3b01 0a07 1077 0dde 4801 0210 0b14 0a8f 0375 2bf4 6205} \\
\texttt{1610 | 622f 6675 0a29 0400 0375 2c1c 6205 6f6c 6b63 0a0c 0e3a 01da 0b09 0a8f 0a29 000a} \\
\texttt{1620 | 0cc8 07ef 0375 2c2a 6605 756c 6873 0375 2c46 7506 6470 7461 0065 0375 2c50 6205} \\
\texttt{1630 | 616c 6b6e 0b34 0db5 0375 2c5c 6c04 7369 0074 15f0 0c8f 01da 0b0e 0a8f 1619 0a29} \\
\texttt{1640 | 000f 0261 0a29 000f 0393 0321 0a29 0003 1077 0de6 0a29 0040 0bb9 0d93 0c8f 034e} \\
\texttt{1650 | 04aa 1642 0294 0375 2c6a 6709 7465 692d 706e 7475 0d50 0b29 0a8a 0d1c 0a9c 0a8a} \\
\texttt{1660 | 0375 2ca8 7309 7465 692d 706e 7475 0a9c 0a8f 0a34 0010 0a8f 0b29 0a8f 0d48 0d23} \\
\texttt{1670 | 0375 2bc4 6f02 006b 0b24 0a8a 0c5f 0dde 2003 6b6f 0c8f 0375 2ce2 6504 6176 006c} \\
\texttt{1680 | 132d 0d05 0441 1689 1203 0a07 0e3a 048f 1680 0294 0a9c 0c58 0375 2cc2 6508 6176} \\
\texttt{1690 | 756c 7461 0065 165a 0d34 0d34 0261 0a07 0a11 0a29 14ac 1667 0a29 2d00 0ded 0210} \\
\texttt{16a0 | 0d3e 0d3e 1667 0e03 0375 2cf8 6c04 6e69 0065 0a29 0006 0cc8 0183 1619 034e 0a29} \\
\texttt{16b0 | 0040 0375 2d4a 6c08 616f 6c64 6e69 0065 16a9 1693 0375 2d1a 6c04 616f 0064 0a07} \\
\texttt{16c0 | 0a29 000f 0261 0bb9 0d34 16b8 0d3e 0a1b 04aa 16c3 0bb2 0375 25d8 6506 6f66 7472} \\
\texttt{16d0 | 0068 0a29 0109 0375 2d64 6904 666e 006f 0c8f 0dde 651b 6f46 7472 2068 3176 392e} \\
\texttt{16e0 | 202c 7550 6c62 6369 4420 6d6f 6961 2c6e 0b61 1099 0c8f 0dde 5229 6369 6168 6472} \\
\texttt{16f0 | 4a20 6d61 7365 4820 776f 2c65 6820 776f 2e65 2e72 2e6a 3938 6740 616d 6c69 632e} \\
\texttt{1700 | 6d6f 0c8f 0dde 6820 7474 7370 2f3a 672f 7469 7568 2e62 6f63 2f6d 6f68 6577 6a72} \\
\texttt{1710 | 732f 6275 656c 0071 0c8f 0375 2da8 7803 6f69 0a29 1e9c 0ac6 0a8f 0abe 0a8f 0ab0} \\
\texttt{1720 | 0a8f 0a9c 0a8f 0375 2e2c 6804 6e61 0064 0a29 2ce8 0a29 1e04 0a29 0006 0a8a 0a0c} \\
\texttt{1730 | 0a7e 0441 1736 0294 0a29 137c 0a29 1e30 0b85 1719 0375 2e48 7004 6361 0065 0a29} \\
\texttt{1740 | 000b 0c88 0375 2e76 6604 6c69 0065 0a29 2e7e 0a29 137c 0a29 1e30 1719 0375 2e86} \\
\texttt{1750 | 6307 6e6f 6f73 656c 0a29 18ce 0aa9 0a8f 0a29 1e04 0aa3 0a8f 1728 0375 2e9e 6903} \\
\texttt{1760 | 216f 1754 0375 2ebc 7409 7361 2d6b 6e69 7469 0a29 0026 0a8a 0183 0a29 0026 0a8f} \\
\texttt{1770 | 0aec 0a85 0a34 0000 0a8f 0a29 1366 0a85 0a34 0002 0a8f 0aec 0a29 0100 034e 0a85} \\
\texttt{1780 | 0a34 0006 0a8f 0aec 0a29 0200 034e 0a85 0a34 0008 0a8f 0a07 0a34 0004 0a8f 0b78} \\
\texttt{1790 | 1761 0a29 23a4 0ab8 0a8f 0a29 1366 0acd 0a8f 0a07 0b29 0a8f 0a11 0b19 0a8f 0aec} \\
\texttt{17a0 | 0a29 0200 034e 0a07 0d48 0d23 0a29 0026 0a8f 0375 2ec6 6903 696e 0a29 0026 0a8a} \\
\texttt{17b0 | 1769 0375 2f54 2807 7265 6f72 2972 01da 0de6 1099 0a29 003f 0c88 0c8f 0a11 0bcf} \\
\texttt{17c0 | 0441 17c3 0180 17ad 0a29 2f6e 0acd 0a8f 0375 2d76 7104 6975 0074 0a29 2f6e 0acd} \\
\texttt{17d0 | 0a8f 0f7e 0a29 2d00 0ded 0b9a 0441 17da 0acd 0c58 048f 17d1 0375 2f64 2806 6f63} \\
\texttt{17e0 | 646c 0029 12d5 1313 17ad 0a29 0006 0a8a 0a29 0004 0a7e 0441 17ee 16d8 0a29 0006} \\
\texttt{17f0 | 0a8a 0a16 0a7e 0441 1813 0a29 0008 0a8a 09f9 01da 0b61 0183 0321 1582 0a29 0028} \\
\texttt{1800 | 0a8a 0bd5 0441 180b 0dde 6209 6461 6320 736b 6d75 0180 0a29 0006 0a8a 0a16 0a6e} \\
\texttt{1810 | 0a29 0006 0a8f 17cd 0375 2fba 7405 7361 3a6b 144f 0b61 1612 0d6d 0a85 1769 0375} \\
\texttt{1820 | 302a 6108 7463 7669 7461 0065 01da 1769 01da 0261 0183 0a85 0183 0a29 0002 034e} \\
\texttt{1830 | 0a8f 0210 0aec 0a8a 0261 01da 0a85 0aec 0a8f 0210 0183 0a8f 0375 3040 7704 6961} \\
\texttt{1840 | 0074 07ef 0a95 0441 1841 0a07 0183 0a8f 0375 307a 7306 6769 616e 006c 0aec 0183} \\
\texttt{1850 | 0a8f 0375 3092 7306 6e69 6c67 0065 0a0c 0a29 004a 0a8f 0375 30a4 6d05 6c75 6974} \\
\texttt{1860 | 0a07 0a29 004a 0a8f 0375 30b8 7304 6e65 0064 0aec 0a5b 0a29 000c 034e 07ef 0a95} \\
\texttt{1870 | 050d 0441 186e 0a8f 0a29 000e 034e 0a8f 0375 30ca 7207 6365 6965 6576 07ef 0a34} \\
\texttt{1880 | 000c 0a8a 0441 187e 0a34 000e 0a8a 0a34 000c 0a8a 0a07 0a34 000c 0a8f 0375 2f92} \\
\texttt{1890 | 6506 6964 6f74 0072 0a29 003e 0a0c 1271 0375 0000 7101 12de 12d5 0375 3132 3f01} \\
\texttt{18a0 | 0b0e 0a8a 1099 0375 313c 6c01 0b0e 0a8a 1639 0375 3148 6501 189b 0b0e 0a8a 16bf} \\
\texttt{18b0 | 1894 0375 3154 6902 0061 0a16 0e3a 0a29 0006 0cc8 034e 0b0e 0a8a 1619 034e 0f77} \\
\texttt{18c0 | 0b29 0a8a 034e 0183 0d50 0b8c 0b29 0a8a 0321 0da3 0f77 0a8a 0b29 0a8f 162d 18a6} \\
\texttt{18d0 | 0375 3164 6901 0a07 0183 18b5 0375 31a2 7701 12f0 0375 31ae 7301 162d 1627 0375} \\
\texttt{18e0 | 31b6 6e01 0a0c 0b0e 0cbc 18a6 0375 31c0 7001 0a11 0b0e 0cbc 18a6 0375 31ce 7201} \\
\texttt{18f0 | 0b0e 0a8f 18a6 0375 31dc 7801 0b0e 0a8a 1619 1612 1632 18a6 0375 31e8 6401 0a0c} \\
\texttt{1900 | 0e3a 0261 0b0e 0a8a 1619 0210 0a29 0006 0cc8 034e 0a29 0040 1632 18a6 0375 311e} \\
\texttt{1910 | 6304 6c6f 0064 0a29 0044 09f9 0c58 0375 }
\hfill \break
The lower 16 bits of all words added together should equal 83b5.
\pagebreak
\section{Credits and goal}
This document contains the code from https://github.com/howerj/subleq and is to be considered as public domain.
The goal of this document is to preserve computing since it should be trivial to implement the interpreter and punch in all of the code.
\end{document}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment