( dovem pro tle )

|00 @System/vector $2 &expansion $2 &wst $1 &rst $1 &metadata $2 &r $2 &g $2 &b $2 &debug $1 &state $1
|10 @Console/vector $2 &read $1 &pad $4 &type $1 &write $1 &error $1
|c0 @DateTime/year $2 &month $1 &day $1 &hour $1 &minute $1 &second $1 &dotw $1 &doty $2 &isdst $1

|000

	@token/+buf ( str[], 00.. )
	$7e &+buf-end $2
	@item/+buf ( str[], 00.. )
	$7e &+buf-end $2

|100

@on-reset ( -> )
	;meta #06 DEO2
	( | Prefabs )
	random/<init>
	;dict/identity syms/find-alloc-force POP2
	( | Modes )
	.Console/type DEI ?{ ;token/on-console-interactive .Console/vector DEO2
		BRK }
	;token/on-console .Console/vector DEO2
	BRK

@meta $1
	( name ) "Rejoice 0a
	( desc ) "Multiset 20 "Language 0a
	( auth ) "By 20 "Devine 20 "Lu 20 "Linvega 0a
	( date ) "28 20 "Apr 20 "2026 $2

%u16/mod ( a* b* -- a%b* ) {
	DIV2k MUL2 SUB2 }

%u16/not-divisible ( u16* div* -- t ) {
	u16/mod ORA }

%char/is-dec ( c -- t ) {
	LIT "0 SUB #0a LTH }

%syms/get-name ( id* -- str* ) {
	DUP2 ADD2 ;syms/buf ADD2 LDA2 }

%label/get-addr ( id* -- addr* ) {
	DUP2 ADD2 ;label/buf ADD2 }

%label/get ( id* -- addr* ) {
	label/get-addr LDA2 }

%item/next ( item* -- next* ) {
	#0004 ADD2 }

(
@|Token )

@token/on-console-interactive ( -> )
	.Console/read DEI DUP /<append>
	#0a NEQ ?{ world/<eval> }
	BRK

@token/on-console ( -> )
	.Console/read DEI /<append>
	[ LIT2 04 -Console/type ] DEI NEQ ?{ world/<eval>
		#800f DEO }
	BRK

@token/on-console-comment ( -> )
	[ LIT2 ") -Console/read ] DEI NEQ ?{
		[ LIT2 &comment-callback $2 ] .Console/vector DEO2 }
	BRK

@token/on-console-string ( -> )
	[ LIT2 "" -Console/read ] DEI NEQk ?{
		[ LIT2 &string-callback $2 ] .Console/vector DEO2
		BRK }
	DUP #20 NEQ ?{
		POP [ LIT "\ ] /<append>
		[ LIT "s ] }
	/<append>
	POP BRK

@token/<append> ( c -- )
	DUP LIT "( NEQ ?{
		.Console/vector DEI2 ,&comment-callback STR2
		;&on-console-comment .Console/vector DEO2
		POP JMP2r }
	DUP LIT "" NEQ ?{
		.Console/vector DEI2 ,&string-callback STR2
		;&on-console-string .Console/vector DEO2
		POP JMP2r }
	DUP LIT "[ NEQ ?{
		,&+depth LDR INC ,&+depth STR }
	DUP LIT "] NEQ ?{
		,&+depth LDR #01 SUB ,&+depth STR }
	[ LIT &+depth $1 ] ?{
		DUP #20 GTH ?{ POP /<parse> !/<reset> } }
	[ LIT2 00 &+ptr -&+buf ] INCk
	( clamp ) .&+buf-end LTHk ?{ ;dict/err-buffer ;dict/token err/<set>
		SWP }
	POP ,&+ptr STR
	STZ2
	JMP2r

@token/<reset> ( -- )
	[ LIT2 -&+buf _&+ptr ] STR
	[ LIT2 00 -&+buf ] STZ
	JMP2r

@token/<parse> ( -- )
	.&+buf
	( exists ) LDZk ?{ POP JMP2r }
	( @label ) LDZk LIT "@ EQU ?label/<parse>
	( 'quote ) LDZk LIT "' EQU ?label/<parse-quote>
	world/<push-scope>
	( >> )

@token/<parse-fraction> ( ztr -- )
	( num bag ) item/parse-any-push world/<pop-scope>
	world/<push-scope>
	LDZk LIT "/ EQU ?{
		( den bag [] ) world/<push-identity>
		world/<pop-scope>
		POP JMP2r }
	INC
	( den bag ) item/parse-any-push world/<pop-scope>
	POP JMP2r

@label/<parse-quote> ( ztr -- )
	#0001 ;&quote-name syms/find-alloc DUP2 /<create>
	world/<push-scope>
	world/<push-count-id>
	,&id LDR INC ,&id STR
	INC !token/<parse-fraction>

	&quote-name "' [ &id "0 00 ]

@label/<parse> ( ztr -- )
	#00 SWP INC syms/find-alloc
	( >> )

@label/<create> ( id* -- )
	/get-addr world/get-ptr SWP2 STA2
	JMP2r

(
@|Bag/Items )

%item/not-quote ( item* -- item* t ) {
	LDA2k syms/get-name LDA LIT "' NEQ }

@item/<print> ( addr* -- )
	INC2k INC2 LDA2 SWP2 LDA2
	( >> )

@item/<print-count-id> ( count* name* -- )
	syms/<print-count-id>
	DUP2 #0002 LTH2 ?{
		[ LIT2 "^ 19 ] DEO
		OVR #80 AND ?{
			( num reg ) !u16/<print-dec> }
		( ref reg ) #7fff AND2 syms/get-name !str/<print> }
	POP2 JMP2r

@item/parse-any-push ( ztr -- ztr )
	LDZk LIT "[ EQU ?/parse-wrap-push
	( >> )

@item/parse-push ( ztr -- ztr )
	LDZk char/is-dec ?/parse-num-push
	LDZk [ LIT "[ ] EQU ?/parse-empty
	( | not numeric )
	[ LIT2 -&+buf _&+ptr ] STR
	&>w
		LDZk DUP symbol/is-spacer ?/parse-sym-push
		/<push>
		INC !&>w

@item/<push> ( c -- )
	[ LIT2 00 &+ptr -&+buf ] INCk
	( clamp ) .&+buf-end LTHk ?{ ;dict/err-buffer ;dict/item err/<set>
		SWP }
	POP ,&+ptr STR
	STZ2
	JMP2r

@item/parse-sym-push ( ztr c -- ztr )
	POP
	( identity ) [ LIT2 -&+buf _&+ptr ] LDR EQU ?world/<push-identity>
	/walk-count ;&+buf
	( | emit symbol )
	LDA2k [ LIT2 ".# ] NEQ2 ?{
		NIP2 INC2k INC2 syms/find-alloc SWP2 }
	syms/find-alloc !world/<push-count-id>

@item/parse-num-push ( ztr -- ztr )
	dec-ztr/walk-u16
	( | check if not number 1 )
	DUP2 #0001 NEQ2 ?{ POP2 !world/<push-identity> }
	( | check if not already prime )
	DUP2 primes/find-id DUP ?/parse-prime
	POP
	( | factorize )
	( value ) [ LIT2r 0002 ]
	&>wpn
		DUP2 #0001 GTH2 ?{ POP2r POP2 JMP2r }
		DUP2 STH2kr u16/not-divisible ?{
			STH2kr
			( | Drain factor )
			[ LITr 00 ]
			&>wpf
				OVR2 OVR2 u16/mod ORA ?{
					INCr STH2k DIV2 STH2r !&>wpf }
			primes/find-id #00 SWP #00 STHr SWP2 world/<push-count-id> }
		INC2r !&>wpn

@item/parse-empty ( ztr -- ztr )
	&>wpe
		LDZk LIT "] NEQ ?{ INC JMP2r }
		INC LDZk ?&>wpe
	JMP2r

@item/parse-prime ( ztr u16* id -- ztr )
	STH
	POP2 /walk-count #00 STHr !world/<push-count-id>

@item/parse-wrap-push ( ztr -- ztr )
	( walk [ ) INC ztr/walk-ws
	&>wwp
		/parse-push ztr/walk-ws LDZk [ LIT "] ] NEQ ?&>wwp
	( walk ] ) INC JMP2r

@item/walk-count ( ztr -- ztr count* )
	LDZk LIT "^ NEQ ?{
		INC LDZk char/is-dec ?{
			DUP symbol/walk
			( ref reg ) #00 ROT syms/find-alloc #8000 ORA2 JMP2r }
		( num reg ) !dec-ztr/walk-u16 }
	( def reg ) #0001 JMP2r

%fraction/den-length ( fraction* -- fraction* len* ) {
	LDA2k LDA2k SWP2 SUB2 }

%fraction/is-unquoted ( fraction* -- fraction* t ) {
	DUP2 INC2k INC2
	( f* num[0].id ) LDA2
	( f* jump* = ) label/get NEQ2 }

%fraction/get-multiplier ( item* -- mul* ) {
	tote/get-register STH2
	LDA2 tote/get-addr LDA2 STH2r DIV2 }

@fraction/<print> ( addr* -- )
	( num ) LDA2k OVR2 INC2 INC2 bag/<print>
	LDA2 INC2k INC2 LDA2 ORA ?{ POP2 JMP2r }
	( den is not [] ) [ LIT2 "/ 19 ] DEO
	( den ) LDA2k SWP2 INC2 INC2
	( >> )

@bag/<print> ( to* from* -- )
	item/not-quote ?{
		LIT "' char/<print>
		INC2 INC2 INC2 INC2 }
	( | Not quote )
	SUB2k #0004 GTH2 ?/<print-complex>
	&>lpb
		DUP2 item/<print>
		item/next GTH2k ?&>lpb
	POP2 POP2 JMP2r

@bag/<print-complex> ( to* from* -- )
	[ LIT2 "[ 19 ] DEO
	&>lpbc
		DUP2 item/<print>
		item/next EQU2k ?{ #2019 DEO }
		GTH2k ?&>lpbc
	POP2 POP2 [ LIT2 "] 19 ] DEO
	JMP2r

(
@|World )

@world/get-ptr ( -- ptr* )
	,&+ptr LDR2 JMP2r

@world/<push-identity> ( -- )
	#0000 #0000
	( >> )

@world/<push-count-id> ( count* id* -- )
	/<push>
	( >> )

@world/<push> ( short* -- )
	[ LIT2 &+ptr =&buf ] INC2k INC2
	( clamp ) ;&buf-end LTH2k ?{ ;dict/err-buffer ;dict/world err/<set>
		SWP2 }
	POP2 ,&+ptr STR2
	STA2
	JMP2r

@world/<push-scope> ( -- )
	,&+ptr LDR2 ,&+scope STR2
	#ffff !/<push>

@world/<pop-scope> ( -- )
	,&+ptr LDR2 [ LIT2 &+scope $2 ] STA2
	JMP2r

@world/<eval> ( -- )
	tote/<clear>
	;&buf [ LIT2r 0001 ]
	&>w
		LDA2k ORA ?{ !&end }
		tote/<print>
		DUP2 tote/<apply>
		DUP2 fraction/<print>
		#0a19 DEO
		goto/step INC2r !&>w

	&end ( addr* -- )
	POP2 tote/<print>
	( | steps )
	;dict/reached-a str/<print>
	STH2r u16/<print-dec>
	;dict/reached-b str/<print>
	syms/get-length #01 SFT2 #0001 SUB2 u16/<print-dec>
	;dict/reached-c !str/<print>

@goto/step ( addr* -- addr* )
	,&+count LDR STHk ?{ POPr LDA2 LDA2 JMP2r }
	POP2 [ LIT2 00 _&+count ] STR
	;&buf ,&+ptr STR2
	STHkr #01 GTH ?{ POPr ;&buf LDA2 JMP2r }
	random/make #00 STHr DIV2k MUL2 SUB2 DUP2 ADD2 ;&buf ADD2 LDA2 JMP2r

@goto/<push> ( addr* -- )
	[ LIT &+count $1 ] INC ,&+count STR
	[ LIT2 &+ptr =&buf ] INC2k INC2
	( clamp ) ;&buf-end LTH2k ?{ ;dict/err-buffer ;dict/goto err/<set>
		SWP2 }
	POP2 ,&+ptr STR2
	STA2
	JMP2r

(
@|Tote )

%tote/get-addr ( id* -- addr* ) {
	DUP2 ADD2 ;tote/buf ADD2 }

%tote/next-cell ( addr* -- next* ) {
	INC2 INC2 }

%tote/has-item ( count* id* -- t ) {
	tote/get-addr LDA2 ADD2 POP #80 AND }

%tote/<mod-item> ( count* id* -- ) {
	tote/get-addr LDA2k ROT2 ADD2 SWP2 STA2 }

@tote/get-register ( item* -- item* value* )
	INC2k INC2 LDA2 OVR #80 AND ?{ JMP2r }
	#7fff AND2 /get-addr LDA2 JMP2r

@tote/<put-print> ( item* name* -- )
	str/<set-print>
	( walk dot ) INC2
	( is emitter ) LDAk LIT "# EQU ?/<put-emit>
	STH2
	/get-register #0000 SWP2 SUB2
	&>lpp
		STH2kr str/<print>
		INC2 ORAk ?&>lpp
	POP2 POP2 POP2r !str/<set-debug>

@tote/<put-emit> ( item* name* -- )
	POP2 INC2 INC2 LDA2 /get-addr LDA2 u16/<print-dec> !str/<set-debug>

@tote/<put> ( item* -- )
	LDA2k syms/get-name
	( dup name* ) LDAk LIT ". EQU ?/<put-print>
	( pop name* ) POP2
	( | detect label )
	LDA2k label/get
	( dup addr* ) ORAk ?/<put-label>
	( pop addr* ) POP2 !queue/<put>

@tote/<put-label> ( item* addr* -- )
	STH2
	INC2 INC2 LDA2 #0000
	&>lpl
		STH2kr goto/<push>
		INC2 GTH2k ?&>lpl
	POP2 POP2 POP2r JMP2r

@tote/<apply> ( fraction* -- )
	( | take )
	queue/<reset>
	LDA2k LDA2k SWP2 /next-cell
	&>lac
		DUP2 queue/<take>
		item/next GTH2k ?&>lac
	POP2 POP2
	( | validate )
	queue/can-apply ?{ POP2 JMP2r }
	( | put )
	LDA2k OVR2 /next-cell
	&>lap
		DUP2 /<put>
		item/next GTH2k ?&>lap
	POP2 POP2
	( | multiplier )
	fraction/is-unquoted ?{
		fraction/den-length #0006 NEQ2 ?{
			LDA2 INC2 INC2 fraction/get-multiplier !queue/<apply> } }
	POP2 #0001 !queue/<apply>

@tote/get-range ( -- to* from* )
	( from* ) ;&buf
	( from* to-ptr* ) DUP2 syms/get-length ADD2 ;&buf-end
	( from* min* ) [ LTH2k JMP SWP2 POP2 ]
	( to* from* ) SWP2 JMP2r

@tote/<print> ( -- )
	[ LIT2 "[ 19 ] DEO
	[ LIT2r ff00 ] /get-range
	&>lp
		LDA2k #0000 EQU2 ?{
			OVRr STHr ?{ #2019 DEO }
			LDA2k #00 STHkr item/<print-count-id>
			LIT2r 00ff AND2r }
		/next-cell INCr GTH2k ?&>lp
	POP2 POP2 POP2r [ LIT2 "] 19 ] DEO
	#2019 DEO
	JMP2r

@tote/<clear> ( -- )
	/get-range
	&>lc
		#0000 OVR2 STA2
		/next-cell GTH2k ?&>lc
	POP2 POP2 JMP2r

@queue/<take> ( item* -- )
	LDA2k /find INC2k ORA ?{
		POP2
		( | Not null )
		tote/get-register ORAk ?{ POP2 POP2 JMP2r }
		SWP2
		( id* ) LDA2 /<push>
		( count* ) #0000 SWP2 SUB2 !/<push> }
	( | merge offset )
	INC2 INC2 STH2
	tote/get-register STH2kr LDA2 SWP2 SUB2 STH2r STA2
	POP2 JMP2r

@queue/<put> ( item* -- item* )
	LDA2k /find INC2k ORA ?{
		POP2
		( | Not null )
		tote/get-register ORAk ?{ POP2 POP2 JMP2r }
		SWP2
		( id* ) LDA2 /<push>
		( count* ) !/<push> }
	( | merge offset )
	INC2 INC2 STH2
	tote/get-register STH2kr LDA2 ADD2 STH2r STA2
	POP2 JMP2r

@queue/<reset> ( -- )
	;&+buf ,&+ptr STR2
	#0000 ;&+buf STA2
	JMP2r

@queue/<apply> ( fraction* mul* -- )
	STH2
	,&+ptr LDR2 ;&+buf
	&>l
		EQU2k ?{
			INC2k INC2 LDA2 STH2kr s16/mul OVR2 LDA2 tote/<mod-item>
			item/next !&>l }
	POP2 POP2 POP2r JMP2r

@queue/<push> ( value* -- )
	[ LIT2 &+ptr =&+buf ] INC2k INC2
	( clamp ) ;&+buf-end LTH2k ?{ ;dict/err-buffer ;dict/queue err/<set>
		SWP2 }
	POP2 ,&+ptr STR2
	STA2
	JMP2r

@queue/find ( item* -- addr* )
	STH2
	,&+ptr LDR2 ;&+buf
	&>lf
		LDA2k STH2kr EQU2 ?{
			item/next GTH2k ?&>lf
		POP2 #ffff }
	NIP2 POP2r JMP2r

@queue/can-apply ( -- t )
	,&+ptr LDR2 ;&+buf
	&>lca
		EQU2k ?{
			( item* count* ) INC2k INC2 LDA2
			( item* count* id* ) OVR2 LDA2 tote/has-item ?{ item/next !&>lca } }
	EQU2 JMP2r

(
@|Dict )

%primes/get-prime ( id* -- prime* ) {
	;primes/lut ADD2 LDA2 }

@primes/find-id ( prime* -- id )
	STH2
	#0000
	&>l
		DUP2k ADD2 /get-prime STH2kr EQU2 ?{ INC DUP ?&>l }
	POP2r NIP JMP2r

@symbol/is-spacer ( c -- t )
	DUP LIT 21 LTH ?{
		DUP LIT "[ EQU ?{
			DUP LIT "/ EQU ?{
				DUP LIT "] EQU ?{ LIT "^ EQU JMP2r } } } }
	POP #01 JMP2r

@symbol/walk ( ztr -- ztr )
	&>ww
		LDZk /is-spacer ?{ INC2 !&>ww }
	JMP2r

@symbol/new ( str* -- str* )
	;&+buf ,&+ptr STR2
	#0000 ;&+buf STA2
	&>wn
		LDAk /is-spacer ?{ LDAk /<push>
			INC2 !&>wn }
	POP2 ;&+buf JMP2r

@symbol/<push> ( c -- )
	#00 [ LIT2 &+ptr =&+buf ] INC2k
	( clamp ) ;&+buf-end LTH2k ?{ ;dict/err-buffer ;dict/symbol err/<set>
		SWP2 }
	POP2 ,&+ptr STR2
	STA2
	JMP2r

@syms/get-length ( -- length* )
	,&+ptr LDR2 ;&buf SUB2 JMP2r

@syms/find ( str* -- id* )
	STH2
	,&+ptr LDR2 ;&buf
	&>lf
		LDA2k STH2kr str/compare ?{
			INC2 INC2 GTH2k ?&>lf
		POP2r POP2 POP2 #ffff JMP2r }
	( | found )
	POP2r NIP2 JMP2r

@syms/find-alloc ( str* -- id* )
	symbol/new
	( >> )
	&find-alloc-force ( str* -- id* )
	LDAk ?{ POP2 #0000 JMP2r }
	DUP2 /find INC2k ORA ?{
		( str* null* ) POP2
		( ptr* str* ) ,&+ptr LDR2 OVR2 dict/alloc
		( | push )
		[ LIT2 &+ptr =&buf ] INC2k INC2
		( clamp ) ;&buf-end LTH2k ?{ ;dict/err-buffer ;dict/syms err/<set>
			SWP2 }
		POP2 ,&+ptr STR2
		STA2 }
	NIP2 ;&buf SUB2 #01 SFT2 JMP2r

@syms/<print-count-id> ( id* -- )
	STH2k /get-name ORAk ?{
		POP2 DUP2r ADD2r STH2r primes/get-prime !u16/<print-dec> }
	POP2r
	( | quoted )
	LDAk LIT "' NEQ ?{ LDA !char/<print> }
	!str/<print>

@dict/alloc ( src* -- ptr* )
	,&+ptr LDR2 SWP2
	&>w
		LDAk DUP [ LIT2 &+ptr =&buf ] INC2k
		( clamp ) ;&buf-end LTH2k ?{ ;&err-buffer ;&dict err/<set>
			SWP2 }
		POP2 ,&+ptr STR2
		STA
		?{ POP2 JMP2r }
		INC2 !&>w

@dict/identity "[] 00 &reached-a 0a "Reached 20 "in 20 00 &reached-b 20 "steps, 20 "with 20 00 &reached-c 20 "symbols. 0a00
	&err-buffer "buffer 20 "overflow. 0a00
	&dict "Dict 00
	&token "Token 00
	&item "Item 00
	&world "World 00
	&goto "Goto 00
	&queue "Queue 00
	&syms "Syms 00
	&symbol "Symbol 00

@err/<set> ( err* name* -- )
	str/<print>
	#2019 DEO
	str/<print>
	#0000 .Console/vector DEO2
	#010f DEO
	JMP2r

(
@|Stdlib )

@dec-ztr/walk-u16 ( ztr -- ztr u16* )
	[ LIT2r 0000 ]
	&>w16
		LDZk LIT "0 SUB DUP #0a LTH ?{
			POP STH2r #7fff AND2 JMP2r }
		[ LIT2r 000a ] MUL2r [ LITr 00 ] STH
		ADD2r INC !&>w16

@str/<print> ( str* -- )
	LDAk DUP ?{ POP POP2 JMP2r }
	( | esc )
	[ LIT &+esc 01 ] ?{
		DUP [ LIT "\ ] NEQ ?{ POP INC2 LDAk char/escape } }
	char/<print>
	INC2 !/<print>

@str/<set-print> ( -- )
	[ LIT2 18 _char/port ] STR
	[ LIT2 00 _&+esc ] STR
	JMP2r

@str/<set-debug> ( -- )
	[ LIT2 19 _char/port ] STR
	[ LIT2 01 _&+esc ] STR
	JMP2r

@char/<print-digit> ( d -- )
	LIT "0 ADD
	( >> )

@char/<print> ( c -- )
	[ LIT &port 19 ] DEO
	JMP2r

@char/escape ( byte -- byte )
	DUP [ LIT "t ] NEQ ?{ POP #09 JMP2r }
	[ LIT "n ] NEQ ?{ #0a JMP2r }
	#20 JMP2r

@ztr/walk-ws ( ztr -- ztr )
	LDZk #20 NEQ ?{ INC !/walk-ws }
	JMP2r

@str/compare ( a* b* -- bool )
	STH2
	&>wc
		LDAk ?{ &d LDA LDAr STHr EQU JMP2r }
		LDAk LDAkr STHr NEQ ?&d
		INC2 INC2r !&>wc

@s16/mul ( val* mul* -- res* )
	STH2
	OVR #80 AND ?{ STH2r MUL2 JMP2r }
	#0000 DUP2 ROT2 SUB2 STH2r MUL2 SUB2 JMP2r

@u16/<print-dec> ( u16* -- )
	[ LIT2r ff00 ]
	&>read
		#000a DIV2k STH2k MUL2 SUB2 STH2r INCr ORAk ?&>read
	POP2
	&>write
		NIP char/<print-digit>
		OVRr ADDr STHkr ?&>write
	POP2r JMP2r

@random/<init> ( -- )
	[ LIT2 00 -DateTime/second ] DEI
	( ) [ LIT2 00 -DateTime/minute ] DEI #60 SFT2 EOR2
	( ) [ LIT2 00 -DateTime/hour ] DEI #c0 SFT2 EOR2 ,&x STR2
	[ LIT2 00 -DateTime/day ] DEI #04 SFT2
	( ) [ LIT2 00 -DateTime/month ] DEI #10 SFT2 EOR2
	( ) [ LIT2 00 -DateTime/second ] DEI #60 SFT2 EOR2
	( ) .DateTime/year DEI2 #a0 SFT2 EOR2 ,&y STR2
	JMP2r

@random/make ( -- number* )
	[ LIT2 &x $2 ]
	( ) DUP2 #50 SFT2 EOR2
	( ) DUP2 #03 SFT2 EOR2
	( ) [ LIT2 &y $2 ]
	( ) DUP2 ,&x STR2
	DUP2 #01 SFT2 EOR2 EOR2
	( ) ,&y STR2k POP JMP2r

(
@|Buffers )

@primes/lut [
	0001 0002 0003 0005 0007 000b 000d 0011
	0013 0017 001d 001f 0025 0029 002b 002f
	0035 003b 003d 0043 0047 0049 004f 0053
	0059 0061 0065 0067 006b 006d 0071 007f
	0083 0089 008b 0095 0097 009d 00a3 00a7
	00ad 00b3 00b5 00bf 00c1 00c5 00c7 00d3
	00df 00e3 00e5 00e9 00ef 00f1 00fb 0101
	0107 010d 010f 0115 0119 011b 0125 0133
	0137 0139 013d 014b 0151 015b 015d 0161
	0167 016f 0175 017b 017f 0185 018d 0191
	0199 01a3 01a5 01af 01b1 01b7 01bb 01c1
	01c9 01cd 01cf 01d3 01df 01e7 01eb 01f3
	01f7 01fd 0209 020b 021d 0223 022d 0233
	0239 023b 0241 024b 0251 0257 0259 025f
	0265 0269 026b 0277 0281 0283 0287 028d
	0293 0295 02a1 02a5 02ab 02b3 02bd 02c5
	02cf 02d7 02dd 02e3 02e7 02ef 02f5 02f9
	0301 0305 0313 031d 0329 032b 0335 0337
	033b 033d 0347 0355 0359 035b 035f 036d
	0371 0373 0377 038b 038f 0397 03a1 03a9
	03ad 03b3 03b9 03c7 03cb 03d1 03d7 03df
	03e5 03f1 03f5 03fb 03fd 0407 0409 040f
	0419 041b 0425 0427 042d 043f 0443 0445
	0449 044f 0455 045d 0463 0469 047f 0481
	048b 0493 049d 04a3 04a9 04b1 04bd 04c1
	04c7 04cd 04cf 04d5 04e1 04eb 04fd 04ff
	0503 0509 050b 0511 0515 0517 051b 0527
	0529 052f 0551 0557 055d 0565 0577 0581
	058f 0593 0595 0599 059f 05a7 05ab 05ad
	05b3 05bf 05c9 05cb 05cf 05d1 05d5 05db
	05e7 05f3 05fb 0607 060d 0611 0617 061f
	0623 062b 062f 063d 0641 0647 0649 064d ]

@symbol/+buf ( str[], 00.. )
	$40 &+buf-end

@syms/buf ( dict*, dict*, dict*, dict*.. )
	$200 &buf-end

@tote/buf ( length*, length*, length*.. )
	$200 &buf-end

@goto/buf ( addr*, addr*.. )
	$200 &buf-end

@label/buf ( addr*, addr*, addr*, addr*.. )
	$200 &buf-end

@dict/buf ( str[], 00, str[], 00.. )
	$400 &buf-end

@queue/+buf ( id*, count*, id*, count*.. )
	$80 &+buf-end

@world/buf ( id*, count*, id*, count*.. )


|fffe &buf-end