1.4

 glossary may include NON_USER words "words" hides.			)
 H3m is case-sensitive. Booleans OR, AND, XOR and NOT are uppercase.	)
 H3m abbreviation/pronounciation  conventions:			)
 )
	?      @	!	->	.	&	'	$	)
	ask    fetch	store	to	print	append	tick	segment	)
 )
 & (append) is to Forth `comma' as assemble is to compile.		)
 @ is usually a copy, -> is usually a move or pop, source is dropped. )
 & in stack comments, e.g. &HNC, sometimes means "address of"	)
 ||| means "stuff to the left is required but not changed".		)
 ?* words like ?char etc. (and flag) produce flagpytes.		)
 format		(optional fields, optional order)		)
 name		`pronounced'  stacks effects  "parsing syntax"  notes)
 )
	ATOMS... )
 address	(P --- ptr ) !rsi  action of named data, Forth VARIABLE )
 AND		( pytea pyteb ---  aANDb ) the bitwise Boolean
 aint		( flagp --- !flagp ) casual NOT, bitwise on lsB.
 align		(P  a  --- a_rounded_up_to_CELLSIZE)		)
 bump		( ---  old_pyte ) undrop. Only useful in threads.
 bbytesd	bump 1->Size drop      )
 bcellsd	bump sizeof(int)->Size drop	 )
 cells		sizeof(int) -> Size		)
 drop		( pyte --- )			)
 dup		( pytea ||| ---	 pytea )  i.e.	  ( a --- a a )	   )
 downshift	( shiftee amount --- shifted ) down-significance bitshift)
 double		up-roll Size by 1, > 256 wraps	)
 doHNC		(P &HNC	 --- ) (R; --- RET|null) execute word given &HNC )
 emit		(pyte --- )  ascii print lsB. not buffered.    )
 ell		unconditional branch to address in next thread cell )
 false		( --- 0flagpyte )  fast false lsB  )
 @		(P ptr ||| --- ) ( --- pyte ) fetch pyte at ptr at Size )
 @+		(P ptr --- ptr+Size ) ( --- pyte )		 )
 getSize	(P --- Size )	 )
 gap		(P a b ||| ) ( --- a-b ) bytes between addresses )
 halve		down-shift Size by 1 bit, Size=Size/2 usually)
 Ha3sm	no-op. No action besides increment VM instruction pointer )
 flag		( pyte --- flagpyte ) OR pyte into lsB, make it a flag )
 ?()=		(P &a &b ||| ) ( ---  flag ) compare pointed-to pytes	)
 ?=		( a b --- flagpyte ) 0xXX..ff (true) if a = b  )
 ?positive	( a  --- flagpyte )  0 considered positive  )
 ip+		( ip_index --- ) execution-array mechanism, computed goto )
 literal	( --- pyte )  in-thread literal pyte number to ds
 max		( a b --- maxab ) Min's hubby.			)
 min		( a b --- min_ab) Max's better half.		)
 maskbyte	( a --- a&0x00...00ff ) mask off all but lsB   )
 move		(P from to |||) (cnt ---)  move cnt bytes, overlaps are OK.
 -?r		( --- flagpyte )  (R c --- c-1) is TOR nonzero before decrement?)
 NOT		( pyte --- !pyte )   bitwise NOT of all bits	)
 negate		( a --- 2's_complement_negative_a )	)
 no		( flagpyte --- ) branch to address in ip (the next cell) if 0  )
 over		( a b --- a b a ) the Forth usual OVER, but on pytes.	)
 onbits		( --- -1 )  all_ones pyte constant, 2's compl. -1 )
 one		( --- 1	 ) 1 as a pyte constant	  )
 OR		( pytea pyteb --- pyteaORb ) bitwise Booolean OR    )
 pdrop		(P ptr --- )  decrement pointer stack index )
 p@		(P ptr1	 ---  ptr2 ) ptr1 overwritten )
 pdup		(P ptra --- ptra ptra )	 )
 pliteral	(P --- lit )	next cell in thread to P.
 +		( a b --- a+b )	 2's-complement addition of pytes  )
 pover		`pea over'  (P a b --- a b a ) pointer-stack OVER )
 p+		( pyte --- ) (P a --- a+(int_part_or_less_of)pyte ) )
 p+s		(P a --- a+Size ) index a pointer by Size	)
 p+1		(P a --- a+1 )	index a pointer by one		)
 p+c		(P a --- a+cellsize ) index a pointer by cellsize (x86 is 4) )
 p-c		(P a --- a-cellsize ) decrement pointer by cellsize (4 on x86) )
 p-1		(P ptr --- ptr+1 ) decrement a pointer			)
 p->		(P a --- ) ( --- a_low[a_hi] ) if (Size > cellsize) then 0-pad	)
 p->r		(P a --- ) (R; --- a ) )
 p->s		(P Size --- )  !Size   superceeded?	)
 p!		`pea store' (P p  store	 |||  ) p goes in store, no pdrops  )
 pswap		(P a b --- b a )	)
 pup		(P ---	oldptr )  pointer stack undrop			)
 return		(R; xt	--- )  VMST rts to calling thread   )
 rdrop		(R; a --- ) )
 rpcopy		(R; a ||| ) (P --- a ) dup r to p   )
 r-1		(R: val --- val-1 )  decrement TOR
 <-r		(R; val --- ) ( --- 0000val )  4 live bytes written to ds  )
 r->p		(R; ptr --- ) (P --- ptr ) symmetrical with p->r. )
 r->s		(R; size --- )	!SIZE )
 swap		( pytea pyteb --- pyteb pytea ) )
 setSize	( Size --- )  Silently refuses to set Size to 0. )
 s->r		(R; --- Size ) Size to return stack		)
 s->p		(P --- Size )  Size to pointer stack		)
 !		(P ptr ||| ) ( pyte --- ) pointer is not dropped )
 sub		(R; --- ip+ ) ip!   go subthread, other uses. Essence of VMST	)
 ->r		(R; --- val ) ( val --- ) Forth >r, ish. 4 bytes moved. )
 ->code		(P &HNC --- Code_Body_Cell ) )
 ->link		(P &HNC --- Link_Cell ) `to link' field )
 ->p		(P --- CELL ) ( a --- ) CELLSIZE worth of a is moved  )
 true		( --- true_flagpyte ) 0xXXX...ff, true flag pyte constant  )
 2pdrop		(P  A B --- )  drop 2 pointers. )
 upshift	( shiftee amount ---  up-shifted-lo [up-shifted-high] ) )
 x		( pyte --- ) print & drop a pyte, Forth "." but hex only )
 XOR		( pytea pyteb --- pyteaXORb ) bitwise exclusive-or	)
 yes		( flagpyte --- )  branch if (lsB of) TOS is true	)
 zero		( --- 0 )   0 as a fast pyte-constant  )
	NAMED DATA )
 ddddddddddddddddddddddddddddddd============			)
 block		(P --- begin_buffer) object data buffer(s) )
 buffer		(P --- begin_buffer) "file" input buffer )
 bsi		counter for branches to resolve		)
 branchstack	space for 16 branches to resolve	)
 digits		(P  ---	 address_of_array ) ascii vals to hex vals map	)
 dp		(P --- dictionary_free-point_pointer )  pointer, unlike HERE  )
 epa		(P --- &epa )  End Parse Area	pointer		)
 hexdigits	(P  ---	 &array )  ascii val is/not a hex digit	  )
 latest		(P --- &HNC ) addr. of HNC of most recent definition  )
 pvar		(P --- &pvar)	scratch pointer for thread resolver  )
 rcfile	(P --- &"rcfile")				)
 sourc		(P --- &input_FD) pointer to FD of source of input )
 thispointer	(P --- &this ) current address in buffered parse area	)
 toklen		token length	)
 targetstack	space for 8 addresses to resolve branches to )
 tokenbuffer	(P --- &token ) where we stash an input token   )
 tsi		counter for branches to resolve )
 USize		(P --- &USize ) offstack Size store for interpreter
 )
	THREADS...
 zygote		top endless loop, do argv[], do rcfile,  
