Finish :makes function for DSL instructions, and plot transitions

[Vaguery]

[Vaguery]

1688a8efb468c811a53bfe8527bd5cfce4592007

[Vaguery]

intermediate result (not available direct from code yet:

:boolean-2bittable {:scalar 1, :booleans 0} -> {:booleans 1}
:boolean-3bittable {:scalar 1, :booleans 0} -> {:booleans 1}
:boolean->code {:boolean 1, :code 0} -> {:code 1}
:boolean->float {:boolean 1, :scalar 0} -> {:scalar 1}
:boolean->integer {:boolean 1, :scalar 0} -> {:scalar 1}
:boolean->signedfloat {:boolean 1, :scalar 0} -> {:scalar 1}
:boolean->signedint {:boolean 1, :scalar 0} -> {:scalar 1}
:boolean->string {:boolean 1, :string 0} -> {:string 1}
:boolean-againlater {:boolean 1, :exec 0} -> {:exec 0, :boolean 1}
:boolean-and {:boolean 2} -> {:boolean 1}
:boolean-arity2 {:scalar 1, :boolean 2} -> {:boolean 1}
:boolean-arity3 {:scalar 1, :boolean 3} -> {:boolean 1}
:boolean-cutflip {:scalar 1, :boolean 0} -> {:boolean 0}
:boolean-cutstack {:scalar 1, :boolean 0} -> {:boolean 0}
:boolean-dup {:boolean 1} -> {:boolean 1}
:boolean-echo {:boolean 1, :generator 0} -> {:generator 1}
:boolean-echoall {:boolean 0, :generator 0} -> {:generator 1}
:boolean-empty? {:boolean 0} -> {:boolean 1}
:boolean-equal? {:boolean 2} -> {:boolean 1}
:boolean-faircoin {:boolean 0} -> {:boolean 1}
:boolean-flipstack {:boolean 0} -> {:boolean 0}
:boolean-flush {:boolean 0} -> {}
:boolean-later {:boolean 1, :exec 0} -> {:exec 0}
:boolean-liftstack {:scalar 1, :boolean 0} -> {:log 1, :boolean 0}
:boolean-not {:boolean 1} -> {:boolean 1}
:boolean-notequal? {:boolean 2} -> {:boolean 1}
:boolean-or {:boolean 2} -> {:boolean 1}
:boolean-pop {:boolean 1} -> {}
:boolean-print {:boolean 1, :print 0} -> {:print 1}
:boolean-rerunall {:boolean 0, :generator 0} -> {:generator 1}
:boolean-return {:boolean 1, :return 0} -> {:return 1}
:boolean-return-pop {:return 0} -> {:return 0}
:boolean-rotate {:boolean 3} -> {:boolean 3}
:boolean-save {:ref 1, :boolean 1} -> {}
:boolean-savestack {:ref 1, :boolean 0} -> {}
:boolean-shove {:scalar 1, :boolean 1} -> {:boolean 0}
:boolean-stackdepth {:boolean 0, :scalar 0} -> {:scalar 1}
:boolean-store {:boolean 1} -> {}
:boolean-storestack {:boolean 0} -> {}
:boolean-swap {:boolean 2} -> {:boolean 2}
:boolean-tag {:boolean 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:boolean-xor {:boolean 2} -> {:boolean 1}
:boolean-yank {:scalar 1, :boolean 1} -> {:boolean 1}
:boolean-yankdup {:scalar 1, :boolean 1} -> {:boolean 1}
:booleans->code {:booleans 1, :code 0} -> {:code 1}
:booleans->tagspace {:booleans 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:booleans-againlater {:booleans 1, :exec 0} -> {:exec 0, :booleans 1}
:booleans-build {:scalar 1, :boolean 0, :booleans 0} -> {:boolean 0, :booleans 1}
:booleans-butlast {:booleans 1} -> {:booleans 1}
:booleans-byexample {:booleans 1, :boolean 0} -> {:booleans 2, :boolean 0}
:booleans-comprehension {:booleans 1, :generator 0} -> {:generator 1}
:booleans-concat {:booleans 2} -> {:booleans 1}
:booleans-conj {:boolean 1, :booleans 1} -> {:booleans 1}
:booleans-contains? {:boolean 1, :booleans 1} -> {:boolean 1}
:booleans-cutflip {:scalar 1, :booleans 0} -> {:booleans 0}
:booleans-cutstack {:scalar 1, :booleans 0} -> {:booleans 0}
:booleans-cycler {:booleans 1, :generator 0} -> {:generator 1}
:booleans-do*each {:booleans 1, :exec 1} -> {:exec 1}
:booleans-dup {:booleans 1} -> {:booleans 1}
:booleans-echo {:booleans 1, :generator 0} -> {:generator 1}
:booleans-echoall {:booleans 0, :generator 0} -> {:generator 1}
:booleans-empty? {:booleans 0, :boolean 0} -> {:boolean 1}
:booleans-emptyitem? {:booleans 1, :boolean 0} -> {:boolean 1}
:booleans-equal? {:booleans 2, :boolean 0} -> {:boolean 1}
:booleans-first {:booleans 1, :boolean 0} -> {:boolean 1}
:booleans-flipstack {:booleans 0} -> {:booleans 0}
:booleans-flush {:booleans 0} -> {}
:booleans-generalize {:booleans 1, :vector 0} -> {:vector 1}
:booleans-generalizeall {:booleans 0, :vector 0} -> {:vector 0}
:booleans-indexof {:boolean 1, :booleans 1, :scalar 0} -> {:scalar 1}
:booleans-last {:booleans 1, :boolean 0} -> {:boolean 1}
:booleans-later {:booleans 1, :exec 0} -> {:exec 0}
:booleans-length {:booleans 1, :scalar 0} -> {:scalar 1}
:booleans-liftstack {:scalar 1, :booleans 0} -> {:log 1, :booleans 0}
:booleans-new {:booleans 0} -> {:booleans 1}
:booleans-notequal? {:booleans 2, :boolean 0} -> {:boolean 1}
:booleans-nth {:booleans 1, :scalar 1, :boolean 0} -> {:boolean 1}
:booleans-occurrencesof {:booleans 1, :boolean 1, :scalar 0} -> {:scalar 1}
:booleans-pop {:booleans 1} -> {}
:booleans-portion {:booleans 1, :scalar 2} -> {:booleans 1}
:booleans-print {:booleans 1, :print 0} -> {:print 1}
:booleans-remove {:booleans 1, :boolean 1} -> {:booleans 1}
:booleans-replace {:booleans 1, :boolean 2} -> {:booleans 1}
:booleans-replacefirst {:booleans 1, :boolean 2} -> {:booleans 1}
:booleans-rerunall {:booleans 0, :generator 0} -> {:generator 1}
:booleans-rest {:booleans 1} -> {:booleans 1}
:booleans-return {:booleans 1, :return 0} -> {:return 1}
:booleans-return-pop {:return 0} -> {:return 0}
:booleans-reverse {:booleans 1} -> {:booleans 1}
:booleans-rotate {:booleans 3} -> {:booleans 3}
:booleans-sampler {:booleans 1, :generator 0} -> {:generator 1}
:booleans-save {:ref 1, :booleans 1} -> {}
:booleans-savestack {:ref 1, :booleans 0} -> {}
:booleans-set {:booleans 1, :boolean 1, :scalar 1} -> {:booleans 1}
:booleans-shatter {:booleans 1, :boolean 0} -> {:boolean 0}
:booleans-shove {:scalar 1, :booleans 1} -> {:booleans 0}
:booleans-stackdepth {:booleans 0, :scalar 0} -> {:scalar 1}
:booleans-store {:booleans 1} -> {}
:booleans-storestack {:booleans 0} -> {}
:booleans-swap {:booleans 2} -> {:booleans 2}
:booleans-tag {:booleans 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:booleans-take {:booleans 1, :scalar 1} -> {:booleans 1}
:booleans-yank {:scalar 1, :booleans 1} -> {:booleans 1}
:booleans-yankdup {:scalar 1, :booleans 1} -> {:booleans 1}
:char->code {:char 1, :code 0} -> {:code 1}
:char->integer {:char 1, :scalar 0} -> {:scalar 1}
:char->string {:char 1, :string 0} -> {:string 1}
:char-againlater {:char 1, :exec 0} -> {:exec 0, :char 1}
:char-cutflip {:scalar 1, :char 0} -> {:char 0}
:char-cutstack {:scalar 1, :char 0} -> {:char 0}
:char-digit? {:char 1, :boolean 0} -> {:boolean 1}
:char-dup {:char 1} -> {:char 1}
:char-echo {:char 1, :generator 0} -> {:generator 1}
:char-echoall {:char 0, :generator 0} -> {:generator 1}
:char-empty? {:char 0, :boolean 0} -> {:boolean 1}
:char-equal? {:char 2, :boolean 0} -> {:boolean 1}
:char-flipstack {:char 0} -> {:char 0}
:char-flush {:char 0} -> {}
:char-later {:char 1, :exec 0} -> {:exec 0}
:char-letter? {:char 1, :boolean 0} -> {:boolean 1}
:char-liftstack {:scalar 1, :char 0} -> {:log 1, :char 0}
:char-lowercase? {:char 1, :boolean 0} -> {:boolean 1}
:char-max {:char 2} -> {:char 1}
:char-min {:char 2} -> {:char 1}
:char-notequal? {:char 2, :boolean 0} -> {:boolean 1}
:char-pop {:char 1} -> {}
:char-print {:char 1, :print 0} -> {:print 1}
:char-rerunall {:char 0, :generator 0} -> {:generator 1}
:char-return {:char 1, :return 0} -> {:return 1}
:char-return-pop {:return 0} -> {:return 0}
:char-rotate {:char 3} -> {:char 3}
:char-save {:ref 1, :char 1} -> {}
:char-savestack {:ref 1, :char 0} -> {}
:char-shove {:scalar 1, :char 1} -> {:char 0}
:char-stackdepth {:char 0, :scalar 0} -> {:scalar 1}
:char-store {:char 1} -> {}
:char-storestack {:char 0} -> {}
:char-swap {:char 2} -> {:char 2}
:char-tag {:char 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:char-uppercase? {:char 1, :boolean 0} -> {:boolean 1}
:char-whitespace? {:char 1, :boolean 0} -> {:boolean 1}
:char-yank {:scalar 1, :char 1} -> {:char 1}
:char-yankdup {:scalar 1, :char 1} -> {:char 1}
:char<? {:char 2, :boolean 0} -> {:boolean 1}
:char>? {:char 2, :boolean 0} -> {:boolean 1}
:chars->code {:chars 1, :code 0} -> {:code 1}
:chars->tagspace {:chars 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:chars-againlater {:chars 1, :exec 0} -> {:exec 0, :chars 1}
:chars-build {:scalar 1, :char 0, :chars 0} -> {:char 0, :chars 1}
:chars-butlast {:chars 1} -> {:chars 1}
:chars-byexample {:chars 1, :char 0} -> {:chars 2, :char 0}
:chars-comprehension {:chars 1, :generator 0} -> {:generator 1}
:chars-concat {:chars 2} -> {:chars 1}
:chars-conj {:char 1, :chars 1} -> {:chars 1}
:chars-contains? {:char 1, :chars 1, :boolean 0} -> {:boolean 1}
:chars-cutflip {:scalar 1, :chars 0} -> {:chars 0}
:chars-cutstack {:scalar 1, :chars 0} -> {:chars 0}
:chars-cycler {:chars 1, :generator 0} -> {:generator 1}
:chars-do*each {:chars 1, :exec 1} -> {:exec 1}
:chars-dup {:chars 1} -> {:chars 1}
:chars-echo {:chars 1, :generator 0} -> {:generator 1}
:chars-echoall {:chars 0, :generator 0} -> {:generator 1}
:chars-empty? {:chars 0, :boolean 0} -> {:boolean 1}
:chars-emptyitem? {:chars 1, :boolean 0} -> {:boolean 1}
:chars-equal? {:chars 2, :boolean 0} -> {:boolean 1}
:chars-first {:chars 1, :char 0} -> {:char 1}
:chars-flipstack {:chars 0} -> {:chars 0}
:chars-flush {:chars 0} -> {}
:chars-generalize {:chars 1, :vector 0} -> {:vector 1}
:chars-generalizeall {:chars 0, :vector 0} -> {:vector 0}
:chars-indexof {:char 1, :chars 1, :scalar 0} -> {:scalar 1}
:chars-last {:chars 1, :char 0} -> {:char 1}
:chars-later {:chars 1, :exec 0} -> {:exec 0}
:chars-length {:chars 1, :scalar 0} -> {:scalar 1}
:chars-liftstack {:scalar 1, :chars 0} -> {:log 1, :chars 0}
:chars-new {:chars 0} -> {:chars 1}
:chars-notequal? {:chars 2, :boolean 0} -> {:boolean 1}
:chars-nth {:chars 1, :scalar 1, :char 0} -> {:char 1}
:chars-occurrencesof {:chars 1, :char 1, :scalar 0} -> {:scalar 1}
:chars-pop {:chars 1} -> {}
:chars-portion {:chars 1, :scalar 2} -> {:chars 1}
:chars-print {:chars 1, :print 0} -> {:print 1}
:chars-remove {:chars 1, :char 1} -> {:chars 1}
:chars-replace {:chars 1, :char 2} -> {:chars 1}
:chars-replacefirst {:chars 1, :char 2} -> {:chars 1}
:chars-rerunall {:chars 0, :generator 0} -> {:generator 1}
:chars-rest {:chars 1} -> {:chars 1}
:chars-return {:chars 1, :return 0} -> {:return 1}
:chars-return-pop {:return 0} -> {:return 0}
:chars-reverse {:chars 1} -> {:chars 1}
:chars-rotate {:chars 3} -> {:chars 3}
:chars-sampler {:chars 1, :generator 0} -> {:generator 1}
:chars-save {:ref 1, :chars 1} -> {}
:chars-savestack {:ref 1, :chars 0} -> {}
:chars-set {:chars 1, :char 1, :scalar 1} -> {:chars 1}
:chars-shatter {:chars 1, :char 0} -> {:char 0}
:chars-shove {:scalar 1, :chars 1} -> {:chars 0}
:chars-stackdepth {:chars 0, :scalar 0} -> {:scalar 1}
:chars-store {:chars 1} -> {}
:chars-storestack {:chars 0} -> {}
:chars-swap {:chars 2} -> {:chars 2}
:chars-tag {:chars 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:chars-take {:chars 1, :scalar 1} -> {:chars 1}
:chars-yank {:scalar 1, :chars 1} -> {:chars 1}
:chars-yankdup {:scalar 1, :chars 1} -> {:chars 1}
:char≤? {:char 2, :boolean 0} -> {:boolean 1}
:char≥? {:char 2, :boolean 0} -> {:boolean 1}
:code->set {:code 1, :set 0} -> {:set 1}
:code->string {:code 1, :string 0} -> {:string 1}
:code-againlater {:code 1, :exec 0} -> {:exec 0, :code 1}
:code-append {:code 2} -> {:code 1}
:code-atom? {:code 1, :boolean 0} -> {:boolean 1}
:code-comprehension {:code 1, :generator 0} -> {:generator 1}
:code-cons {:code 2} -> {:code 1}
:code-container {:code 2} -> {:code 1}
:code-contains? {:code 2, :boolean 0} -> {:boolean 1}
:code-cutflip {:scalar 1, :code 0} -> {:code 0}
:code-cutstack {:scalar 1, :code 0} -> {:code 0}
:code-cycler {:code 1, :generator 0} -> {:generator 1}
:code-do {:code 1, :exec 0} -> {:exec 1}
:code-do* {:code 1, :exec 0} -> {:exec 1}
:code-do*count {:code 1, :scalar 1, :exec 0} -> {:exec 1}
:code-do*range {:code 1, :scalar 2, :exec 0} -> {:exec 1}
:code-do*times {:code 1, :scalar 1, :exec 0} -> {:exec 1}
:code-drop {:code 1, :scalar 1} -> {:code 1}
:code-dup {:code 1} -> {:code 1}
:code-echo {:code 1, :generator 0} -> {:generator 1}
:code-echoall {:code 0, :generator 0} -> {:generator 1}
:code-empty? {:code 0, :boolean 0} -> {:boolean 1}
:code-equal? {:code 2, :boolean 0} -> {:boolean 1}
:code-extract {:code 1, :scalar 1} -> {:code 1}
:code-first {:code 1} -> {:code 1}
:code-flipstack {:code 0} -> {:code 0}
:code-flush {:code 0} -> {}
:code-if {:code 2, :boolean 1, :exec 0} -> {:exec 1}
:code-insert {:code 2, :scalar 1} -> {:code 1}
:code-later {:code 1, :exec 0} -> {:exec 0}
:code-length {:code 1, :scalar 0} -> {:scalar 1}
:code-liftstack {:scalar 1, :code 0} -> {:log 1, :code 0}
:code-list {:code 2} -> {:code 1}
:code-map {:code 1, :exec 1} -> {:exec 1}
:code-member? {:code 2, :boolean 0} -> {:boolean 1}
:code-noop:  -> 
:code-notequal? {:code 2, :boolean 0} -> {:boolean 1}
:code-nth {:code 1, :scalar 1} -> {:code 1}
:code-null? {:code 1, :boolean 0} -> {:boolean 1}
:code-points {:code 1, :scalar 0} -> {:scalar 1}
:code-pop {:code 1} -> {}
:code-position {:code 2, :scalar 0} -> {:scalar 1}
:code-print {:code 1, :print 0} -> {:print 1}
:code-quote {:exec 1, :code 0} -> {:code 1}
:code-reduce {:code 1, :exec 1} -> {:exec 1}
:code-rerunall {:code 0, :generator 0} -> {:generator 1}
:code-rest {:code 1} -> {:code 1}
:code-return {:code 1, :return 0} -> {:return 1}
:code-return-pop {:return 0} -> {:return 0}
:code-rotate {:code 3} -> {:code 3}
:code-sampler {:code 1, :generator 0} -> {:generator 1}
:code-save {:ref 1, :code 1} -> {}
:code-savestack {:ref 1, :code 0} -> {}
:code-shove {:scalar 1, :code 1} -> {:code 0}
:code-size {:code 1, :scalar 0} -> {:scalar 1}
:code-stackdepth {:code 0, :scalar 0} -> {:scalar 1}
:code-store {:code 1} -> {}
:code-storestack {:code 0} -> {}
:code-subst {:code 3} -> {:code 1}
:code-swap {:code 2} -> {:code 2}
:code-tag {:code 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:code-wrap {:code 1} -> {:code 1}
:code-yank {:scalar 1, :code 1} -> {:code 1}
:code-yankdup {:scalar 1, :code 1} -> {:code 1}
:complex->code {:complex 1, :code 0} -> {:code 1}
:complex-add {:complex 2} -> {:complex 1, :log 1}
:complex-againlater {:complex 1, :exec 0} -> {:exec 0, :complex 1}
:complex-conjugate {:complex 1} -> {:complex 1}
:complex-cutflip {:scalar 1, :complex 0} -> {:complex 0}
:complex-cutstack {:scalar 1, :complex 0} -> {:complex 0}
:complex-divide {:complex 2} -> {:complex 1, :log 1}
:complex-dup {:complex 1} -> {:complex 1}
:complex-echo {:complex 1, :generator 0} -> {:generator 1}
:complex-echoall {:complex 0, :generator 0} -> {:generator 1}
:complex-empty? {:complex 0, :boolean 0} -> {:boolean 1}
:complex-equal? {:complex 2, :boolean 0} -> {:boolean 1}
:complex-flipstack {:complex 0} -> {:complex 0}
:complex-flush {:complex 0} -> {}
:complex-later {:complex 1, :exec 0} -> {:exec 0}
:complex-liftstack {:scalar 1, :complex 0} -> {:log 1, :complex 0}
:complex-multiply {:complex 2} -> {:complex 1, :log 1}
:complex-notequal? {:complex 2, :boolean 0} -> {:boolean 1}
:complex-parts {:complex 1, :exec 0} -> {:exec 1}
:complex-pop {:complex 1} -> {}
:complex-print {:complex 1, :print 0} -> {:print 1}
:complex-reciprocal {:complex 1} -> {:complex 1, :log 1}
:complex-rerunall {:complex 0, :generator 0} -> {:generator 1}
:complex-return {:complex 1, :return 0} -> {:return 1}
:complex-return-pop {:return 0} -> {:return 0}
:complex-rotate {:complex 3} -> {:complex 3}
:complex-save {:ref 1, :complex 1} -> {}
:complex-savestack {:ref 1, :complex 0} -> {}
:complex-scale {:scalar 1, :complex 1} -> {:complex 1}
:complex-shift {:scalar 1, :complex 1} -> {:complex 1}
:complex-shove {:scalar 1, :complex 1} -> {:complex 0}
:complex-stackdepth {:complex 0, :scalar 0} -> {:scalar 1}
:complex-store {:complex 1} -> {}
:complex-storestack {:complex 0} -> {}
:complex-subtract {:complex 2} -> {:complex 1, :log 1}
:complex-swap {:complex 2} -> {:complex 2}
:complex-tag {:complex 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:complex-yank {:scalar 1, :complex 1} -> {:complex 1}
:complex-yankdup {:scalar 1, :complex 1} -> {:complex 1}
:complex-zero {:complex 0} -> {:complex 1}
:complexes->code {:complexes 1, :code 0} -> {:code 1}
:complexes->tagspace {:complexes 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:complexes-againlater {:complexes 1, :exec 0} -> {:exec 0, :complexes 1}
:complexes-build {:scalar 1, :complex 0, :complexes 0} -> {:complex 0, :complexes 1}
:complexes-butlast {:complexes 1} -> {:complexes 1}
:complexes-byexample {:complexes 1, :complex 0} -> {:complexes 2, :complex 0}
:complexes-comprehension {:complexes 1, :generator 0} -> {:generator 1}
:complexes-concat {:complexes 2} -> {:complexes 1}
:complexes-conj {:complex 1, :complexes 1} -> {:complexes 1}
:complexes-contains? {:complex 1, :complexes 1, :boolean 0} -> {:boolean 1}
:complexes-cutflip {:scalar 1, :complexes 0} -> {:complexes 0}
:complexes-cutstack {:scalar 1, :complexes 0} -> {:complexes 0}
:complexes-cycler {:complexes 1, :generator 0} -> {:generator 1}
:complexes-do*each {:complexes 1, :exec 1} -> {:exec 1}
:complexes-dup {:complexes 1} -> {:complexes 1}
:complexes-echo {:complexes 1, :generator 0} -> {:generator 1}
:complexes-echoall {:complexes 0, :generator 0} -> {:generator 1}
:complexes-empty? {:complexes 0, :boolean 0} -> {:boolean 1}
:complexes-emptyitem? {:complexes 1, :boolean 0} -> {:boolean 1}
:complexes-equal? {:complexes 2, :boolean 0} -> {:boolean 1}
:complexes-first {:complexes 1, :complex 0} -> {:complex 1}
:complexes-flipstack {:complexes 0} -> {:complexes 0}
:complexes-flush {:complexes 0} -> {}
:complexes-generalize {:complexes 1, :vector 0} -> {:vector 1}
:complexes-generalizeall {:complexes 0, :vector 0} -> {:vector 0}
:complexes-indexof {:complex 1, :complexes 1, :scalar 0} -> {:scalar 1}
:complexes-last {:complexes 1, :complex 0} -> {:complex 1}
:complexes-later {:complexes 1, :exec 0} -> {:exec 0}
:complexes-length {:complexes 1, :scalar 0} -> {:scalar 1}
:complexes-liftstack {:scalar 1, :complexes 0} -> {:log 1, :complexes 0}
:complexes-new {:complexes 0} -> {:complexes 1}
:complexes-notequal? {:complexes 2, :boolean 0} -> {:boolean 1}
:complexes-nth {:complexes 1, :scalar 1, :complex 0} -> {:complex 1}
:complexes-occurrencesof {:complexes 1, :complex 1, :scalar 0} -> {:scalar 1}
:complexes-pop {:complexes 1} -> {}
:complexes-portion {:complexes 1, :scalar 2} -> {:complexes 1}
:complexes-print {:complexes 1, :print 0} -> {:print 1}
:complexes-remove {:complexes 1, :complex 1} -> {:complexes 1}
:complexes-replace {:complexes 1, :complex 2} -> {:complexes 1}
:complexes-replacefirst {:complexes 1, :complex 2} -> {:complexes 1}
:complexes-rerunall {:complexes 0, :generator 0} -> {:generator 1}
:complexes-rest {:complexes 1} -> {:complexes 1}
:complexes-return {:complexes 1, :return 0} -> {:return 1}
:complexes-return-pop {:return 0} -> {:return 0}
:complexes-reverse {:complexes 1} -> {:complexes 1}
:complexes-rotate {:complexes 3} -> {:complexes 3}
:complexes-sampler {:complexes 1, :generator 0} -> {:generator 1}
:complexes-save {:ref 1, :complexes 1} -> {}
:complexes-savestack {:ref 1, :complexes 0} -> {}
:complexes-set {:complexes 1, :complex 1, :scalar 1} -> {:complexes 1}
:complexes-shatter {:complexes 1, :complex 0} -> {:complex 0}
:complexes-shove {:scalar 1, :complexes 1} -> {:complexes 0}
:complexes-stackdepth {:complexes 0, :scalar 0} -> {:scalar 1}
:complexes-store {:complexes 1} -> {}
:complexes-storestack {:complexes 0} -> {}
:complexes-swap {:complexes 2} -> {:complexes 2}
:complexes-tag {:complexes 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:complexes-take {:complexes 1, :scalar 1} -> {:complexes 1}
:complexes-yank {:scalar 1, :complexes 1} -> {:complexes 1}
:complexes-yankdup {:scalar 1, :complexes 1} -> {:complexes 1}
:environment-begin {:exec 0, :environment 0, :return 0} -> {:exec 0}
:environment-empty? {:environment 0, :boolean 0} -> {:boolean 1}
:environment-end {:exec 0, :return 0, :environment 1} -> {:exec 0}
:environment-new {:exec 1, :environment 0, :return 0} -> {:exec 1}
:environment-stackdepth {:environment 0, :scalar 0} -> {:scalar 1}
:error-empty? {:error 0, :boolean 0} -> {:boolean 1}
:error-stackdepth {:error 0, :scalar 0} -> {:scalar 1}
:exec->string {:exec 1, :string 0} -> {:string 1}
:exec-againlater {:exec 1} -> {:exec 1}
:exec-comprehension {:exec 1, :generator 0} -> {:generator 1}
:exec-cutflip {:scalar 1, :exec 0} -> {:exec 0}
:exec-cutstack {:scalar 1, :exec 0} -> {:exec 0}
:exec-cycler {:exec 1, :generator 0} -> {:generator 1}
:exec-do*count {:exec 1, :scalar 1} -> {:exec 1}
:exec-do*range {:exec 1, :scalar 2} -> {:exec 1}
:exec-do*times {:exec 1, :scalar 1} -> {:exec 1}
:exec-do*while {:exec 1} -> {:exec 1}
:exec-dup {:exec 1} -> {:exec 1}
:exec-echo {:exec 1, :generator 0} -> {:generator 1}
:exec-echoall {:exec 0, :generator 0} -> {:generator 1}
:exec-empty? {:exec 0, :boolean 0} -> {:boolean 1}
:exec-equal? {:exec 2, :boolean 0} -> {:boolean 1}
:exec-flipstack {:exec 0} -> {:exec 0}
:exec-flush {:exec 0} -> {}
:exec-if {:boolean 1, :exec 2} -> {:exec 1}
:exec-k {:exec 2} -> {:exec 1}
:exec-later {:exec 1} -> {:exec 0}
:exec-liftstack {:scalar 1, :exec 0} -> {:log 1, :exec 0}
:exec-noop:  -> 
:exec-notequal? {:exec 2, :boolean 0} -> {:boolean 1}
:exec-pop {:exec 1} -> {}
:exec-print {:exec 1, :print 0} -> {:print 1}
:exec-rerunall {:exec 0, :generator 0} -> {:generator 1}
:exec-return {:exec 1, :return 0} -> {:return 1}
:exec-return-pop {:return 0} -> {:return 0}
:exec-rotate {:exec 3} -> {:exec 3}
:exec-s {:exec 3} -> {:exec 3}
:exec-sampler {:exec 1, :generator 0} -> {:generator 1}
:exec-save {:ref 1, :exec 1} -> {}
:exec-savestack {:ref 1, :exec 0} -> {}
:exec-shove {:scalar 1, :exec 1} -> {:exec 0}
:exec-stackdepth {:exec 0, :scalar 0} -> {:scalar 1}
:exec-store {:exec 1} -> {}
:exec-storestack {:exec 0} -> {}
:exec-string-iterate {:string 1, :exec 1} -> {:exec 1}
:exec-swap {:exec 2} -> {:exec 2}
:exec-tag {:exec 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:exec-when {:exec 1, :boolean 1} -> {:exec 1}
:exec-while {:exec 1, :boolean 1} -> {:exec 1}
:exec-y {:exec 1} -> {:exec 1}
:exec-yank {:scalar 1, :exec 1} -> {:exec 1}
:exec-yankdup {:scalar 1, :exec 1} -> {:exec 1}
:float-uniform {:scalar 1} -> {:scalar 1, :log 1}
:generator->code {:generator 1, :code 0} -> {:code 1}
:generator-again {:generator 1, :exec 0} -> {:exec 1}
:generator-againlater {:generator 1, :exec 0} -> {:exec 0, :generator 1}
:generator-counter {:scalar 1, :generator 0} -> {:generator 1}
:generator-cutflip {:scalar 1, :generator 0} -> {:generator 0}
:generator-cutstack {:scalar 1, :generator 0} -> {:generator 0}
:generator-dup {:generator 1} -> {:generator 1}
:generator-echo {:generator 1} -> {:generator 1}
:generator-echoall {:generator 0} -> {:generator 1}
:generator-empty? {:generator 0, :boolean 0} -> {:boolean 1}
:generator-flipstack {:generator 0} -> {:generator 0}
:generator-flush {:generator 0} -> {}
:generator-jumpsome {:generator 1, :scalar 1} -> {:generator 1}
:generator-later {:generator 1, :exec 0} -> {:exec 0}
:generator-liftstack {:scalar 1, :generator 0} -> {:log 1, :generator 0}
:generator-next {:generator 1, :exec 0} -> {:exec 1}
:generator-pop {:generator 1} -> {}
:generator-rerunall {:generator 0} -> {:generator 1}
:generator-reset {:generator 1} -> {:generator 1}
:generator-return {:generator 1, :return 0} -> {:return 1}
:generator-return-pop {:return 0} -> {:return 0}
:generator-rotate {:generator 3} -> {:generator 3}
:generator-save {:ref 1, :generator 1} -> {}
:generator-savestack {:ref 1, :generator 0} -> {}
:generator-shove {:scalar 1, :generator 1} -> {:generator 0}
:generator-stackdepth {:generator 0, :scalar 0} -> {:scalar 1}
:generator-stepper {:scalar 2, :generator 0} -> {:generator 1}
:generator-store {:generator 1} -> {}
:generator-storestack {:generator 0} -> {}
:generator-swap {:generator 2} -> {:generator 2}
:generator-tag {:generator 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:generator-totalistic3 {:scalar 1, :generator 0} -> {:generator 1}
:generator-yank {:scalar 1, :generator 1} -> {:generator 1}
:generator-yankdup {:scalar 1, :generator 1} -> {:generator 1}
:integer-totalistic3 {:scalar 1} -> {:scalar 1}
:integer-uniform {:scalar 1} -> {:scalar 1, :log 1}
:log-empty? {:log 0, :boolean 0} -> {:boolean 1}
:log-stackdepth {:log 0, :scalar 0} -> {:scalar 1}
:print-empty? {:print 0, :boolean 0} -> {:boolean 1}
:print-newline {:print 0} -> {:print 1}
:print-space {:print 0} -> {:print 1}
:print-stackdepth {:print 0, :scalar 0} -> {:scalar 1}
:push-bindingcount {:scalar 0} -> {:scalar 1}
:push-bindings {:code 0} -> {:code 1}
:push-bindingset {:set 0} -> {:set 1}
:push-counter {:scalar 0} -> {:scalar 2}
:push-discardARGS {} -> {}
:push-instructionset {:set 0} -> {:set 1}
:push-nthref {:scalar 1, :ref 0} -> {:ref 1}
:push-quoterefs {} -> {}
:push-refcycler {:exec 0} -> {:exec 1}
:push-storeARGS {} -> {}
:push-unquoterefs {} -> {}
:ref->code {:ref 1, :code 0} -> {:code 1}
:ref-againlater {:ref 1, :exec 0} -> {:exec 0, :ref 1}
:ref-ARGS {:exec 0, :ref 0} -> {:exec 1, :ref 1}
:ref-clear {:ref 1} -> {}
:ref-cutflip {:scalar 1, :ref 0} -> {:ref 0}
:ref-cutstack {:scalar 1, :ref 0} -> {:ref 0}
:ref-dump {:ref 1, :exec 0} -> {:exec 1}
:ref-dup {:ref 1} -> {:ref 1}
:ref-echo {:ref 1, :generator 0} -> {:generator 1}
:ref-echoall {:ref 0, :generator 0} -> {:generator 1}
:ref-empty? {:ref 0, :boolean 0} -> {:boolean 1}
:ref-equal? {:ref 2, :boolean 0} -> {:boolean 1}
:ref-exchange {:ref 2} -> {}
:ref-flipstack {:ref 0} -> {:ref 0}
:ref-flush {:ref 0} -> {}
:ref-forget {:ref 1} -> {}
:ref-fullquote {:ref 1, :code 0} -> {:code 1}
:ref-known? {:ref 1, :boolean 0} -> {:boolean 1}
:ref-later {:ref 1, :exec 0} -> {:exec 0}
:ref-liftstack {:scalar 1, :ref 0} -> {:log 1, :ref 0}
:ref-lookup {:ref 1, :exec 0} -> {:exec 1}
:ref-new {:ref 0} -> {:ref 1}
:ref-notequal? {:ref 2, :boolean 0} -> {:boolean 1}
:ref-peek {:ref 1, :exec 0} -> {:exec 1, :ref 1}
:ref-pop {:ref 1} -> {}
:ref-print {:ref 1, :print 0} -> {:print 1}
:ref-rerunall {:ref 0, :generator 0} -> {:generator 1}
:ref-return {:ref 1, :return 0} -> {:return 1}
:ref-return-pop {:return 0} -> {:return 0}
:ref-rotate {:ref 3} -> {:ref 3}
:ref-save {:ref 2} -> {}
:ref-savestack {:ref 1} -> {}
:ref-shove {:scalar 1, :ref 1} -> {:ref 0}
:ref-stackdepth {:ref 0, :scalar 0} -> {:scalar 1}
:ref-store {:ref 1} -> {}
:ref-storestack {:ref 0} -> {}
:ref-swap {:ref 2} -> {:ref 2}
:ref-tag {:ref 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:ref-yank {:scalar 1, :ref 1} -> {:ref 1}
:ref-yankdup {:scalar 1, :ref 1} -> {:ref 1}
:refs->code {:refs 1, :code 0} -> {:code 1}
:refs->tagspace {:refs 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:refs-againlater {:refs 1, :exec 0} -> {:exec 0, :refs 1}
:refs-build {:scalar 1, :ref 0, :refs 0} -> {:ref 0, :refs 1}
:refs-butlast {:refs 1} -> {:refs 1}
:refs-byexample {:refs 1, :ref 0} -> {:refs 2, :ref 0}
:refs-comprehension {:refs 1, :generator 0} -> {:generator 1}
:refs-concat {:refs 2} -> {:refs 1}
:refs-conj {:ref 1, :refs 1} -> {:refs 1}
:refs-contains? {:ref 1, :refs 1, :boolean 0} -> {:boolean 1}
:refs-cutflip {:scalar 1, :refs 0} -> {:refs 0}
:refs-cutstack {:scalar 1, :refs 0} -> {:refs 0}
:refs-cycler {:refs 1, :generator 0} -> {:generator 1}
:refs-do*each {:refs 1, :exec 1} -> {:exec 1}
:refs-dup {:refs 1} -> {:refs 1}
:refs-echo {:refs 1, :generator 0} -> {:generator 1}
:refs-echoall {:refs 0, :generator 0} -> {:generator 1}
:refs-empty? {:refs 0, :boolean 0} -> {:boolean 1}
:refs-emptyitem? {:refs 1, :boolean 0} -> {:boolean 1}
:refs-equal? {:refs 2, :boolean 0} -> {:boolean 1}
:refs-first {:refs 1, :ref 0} -> {:ref 1}
:refs-flipstack {:refs 0} -> {:refs 0}
:refs-flush {:refs 0} -> {}
:refs-generalize {:refs 1, :vector 0} -> {:vector 1}
:refs-generalizeall {:refs 0, :vector 0} -> {:vector 0}
:refs-indexof {:ref 1, :refs 1, :scalar 0} -> {:scalar 1}
:refs-last {:refs 1, :ref 0} -> {:ref 1}
:refs-later {:refs 1, :exec 0} -> {:exec 0}
:refs-length {:refs 1, :scalar 0} -> {:scalar 1}
:refs-liftstack {:scalar 1, :refs 0} -> {:log 1, :refs 0}
:refs-new {:refs 0} -> {:refs 1}
:refs-notequal? {:refs 2, :boolean 0} -> {:boolean 1}
:refs-nth {:refs 1, :scalar 1, :ref 0} -> {:ref 1}
:refs-occurrencesof {:refs 1, :ref 1, :scalar 0} -> {:scalar 1}
:refs-pop {:refs 1} -> {}
:refs-portion {:refs 1, :scalar 2} -> {:refs 1}
:refs-print {:refs 1, :print 0} -> {:print 1}
:refs-remove {:refs 1, :ref 1} -> {:refs 1}
:refs-replace {:refs 1, :ref 2} -> {:refs 1}
:refs-replacefirst {:refs 1, :ref 2} -> {:refs 1}
:refs-rerunall {:refs 0, :generator 0} -> {:generator 1}
:refs-rest {:refs 1} -> {:refs 1}
:refs-return {:refs 1, :return 0} -> {:return 1}
:refs-return-pop {:return 0} -> {:return 0}
:refs-reverse {:refs 1} -> {:refs 1}
:refs-rotate {:refs 3} -> {:refs 3}
:refs-sampler {:refs 1, :generator 0} -> {:generator 1}
:refs-save {:ref 1, :refs 1} -> {}
:refs-savestack {:ref 1, :refs 0} -> {}
:refs-set {:refs 1, :ref 1, :scalar 1} -> {:refs 1}
:refs-shatter {:refs 1, :ref 0} -> {:ref 0}
:refs-shove {:scalar 1, :refs 1} -> {:refs 0}
:refs-stackdepth {:refs 0, :scalar 0} -> {:scalar 1}
:refs-store {:refs 1} -> {}
:refs-storestack {:refs 0} -> {}
:refs-swap {:refs 2} -> {:refs 2}
:refs-tag {:refs 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:refs-take {:refs 1, :scalar 1} -> {:refs 1}
:refs-yank {:scalar 1, :refs 1} -> {:refs 1}
:refs-yankdup {:scalar 1, :refs 1} -> {:refs 1}
:scalar->asciichar {:scalar 1, :char 0} -> {:char 1}
:scalar->boolean {:scalar 1, :boolean 0} -> {:boolean 1}
:scalar->char {:scalar 1, :char 0} -> {:char 1}
:scalar->code {:scalar 1, :code 0} -> {:code 1}
:scalar->complex {:scalar 2, :complex 0} -> {:complex 1}
:scalar->string {:scalar 1, :string 0} -> {:string 1}
:scalar-abs {:scalar 1} -> {:scalar 1}
:scalar-add {:scalar 2} -> {:scalar 1, :log 1}
:scalar-againlater {:scalar 1, :exec 0} -> {:exec 0, :scalar 1}
:scalar-arccosine {:scalar 1} -> {:scalar 1, :log 1}
:scalar-arcsine {:scalar 1} -> {:scalar 1, :log 1}
:scalar-arctangent {:scalar 1} -> {:scalar 1}
:scalar-bigdec? {:scalar 1, :boolean 0} -> {:boolean 1}
:scalar-ceiling {:scalar 1} -> {:scalar 1}
:scalar-complexify {:scalar 1, :complex 0} -> {:complex 1}
:scalar-cosine {:scalar 1} -> {:scalar 1}
:scalar-cutflip {:scalar 1} -> {:scalar 0}
:scalar-cutstack {:scalar 1} -> {:scalar 0}
:scalar-dec {:scalar 1} -> {:scalar 1}
:scalar-divide {:scalar 2} -> {:scalar 1, :log 1}
:scalar-dup {:scalar 1} -> {:scalar 1}
:scalar-E {:scalar 0} -> {:scalar 1}
:scalar-echo {:scalar 1, :generator 0} -> {:generator 1}
:scalar-echoall {:scalar 0, :generator 0} -> {:generator 1}
:scalar-empty? {:scalar 0, :boolean 0} -> {:boolean 1}
:scalar-equal? {:scalar 2, :boolean 0} -> {:boolean 1}
:scalar-few {:scalar 1} -> {:scalar 1}
:scalar-flipstack {:scalar 0} -> {:scalar 0}
:scalar-float? {:scalar 1, :boolean 0} -> {:boolean 1}
:scalar-floor {:scalar 1} -> {:scalar 1}
:scalar-flush {:scalar 0} -> {}
:scalar-fractional {:scalar 1} -> {:scalar 1}
:scalar-inc {:scalar 1} -> {:scalar 1}
:scalar-integer? {:scalar 1, :boolean 0} -> {:boolean 1}
:scalar-later {:scalar 1, :exec 0} -> {:exec 0}
:scalar-liftstack {:scalar 1} -> {:log 1, :scalar 0}
:scalar-ln {:scalar 1} -> {:scalar 1, :log 1}
:scalar-ln1p {:scalar 1} -> {:scalar 1, :log 1}
:scalar-log10 {:scalar 1} -> {:scalar 1, :log 1}
:scalar-lots {:scalar 1} -> {:scalar 1}
:scalar-many {:scalar 1} -> {:scalar 1}
:scalar-max {:scalar 2} -> {:scalar 1}
:scalar-min {:scalar 2} -> {:scalar 1}
:scalar-modulo {:scalar 2} -> {:scalar 1, :log 1}
:scalar-multiply {:scalar 2} -> {:scalar 1, :log 1}
:scalar-notequal? {:scalar 2, :boolean 0} -> {:boolean 1}
:scalar-pop {:scalar 1} -> {}
:scalar-print {:scalar 1, :print 0} -> {:print 1}
:scalar-ratio? {:scalar 1, :boolean 0} -> {:boolean 1}
:scalar-reciprocal {:scalar 1} -> {:scalar 1}
:scalar-rerunall {:scalar 0, :generator 0} -> {:generator 1}
:scalar-return {:scalar 1, :return 0} -> {:return 1}
:scalar-return-pop {:return 0} -> {:return 0}
:scalar-rotate {:scalar 3} -> {:scalar 3}
:scalar-round {:scalar 1} -> {:scalar 1}
:scalar-save {:ref 1, :scalar 1} -> {}
:scalar-savestack {:ref 1, :scalar 0} -> {}
:scalar-shove {:scalar 2} -> {:scalar 0}
:scalar-sign {:scalar 1} -> {:scalar 1}
:scalar-sine {:scalar 1} -> {:scalar 1}
:scalar-some {:scalar 1} -> {:scalar 1}
:scalar-sqrt {:scalar 1} -> {:scalar 1, :log 1}
:scalar-stackdepth {:scalar 0} -> {:scalar 1}
:scalar-store {:scalar 1} -> {}
:scalar-storestack {:scalar 0} -> {}
:scalar-subtract {:scalar 2} -> {:scalar 1, :log 1}
:scalar-swap {:scalar 2} -> {:scalar 2}
:scalar-tag {:scalar 2, :tagspace 1} -> {:tagspace 1}
:scalar-tangent {:scalar 1} -> {:scalar 1, :log 1}
:scalar-yank {:scalar 2} -> {:scalar 1}
:scalar-yankdup {:scalar 2} -> {:scalar 1}
:scalar-π {:scalar 0} -> {:scalar 1}
:scalar<? {:scalar 2, :boolean 0} -> {:boolean 1}
:scalar>? {:scalar 2, :boolean 0} -> {:boolean 1}
:scalars->code {:scalars 1, :code 0} -> {:code 1}
:scalars->tagspace {:scalars 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:scalars-againlater {:scalars 1, :exec 0} -> {:exec 0, :scalars 1}
:scalars-build {:scalar 1, :scalars 0} -> {:scalar 0, :scalars 1}
:scalars-butlast {:scalars 1} -> {:scalars 1}
:scalars-byexample {:scalars 1, :scalar 0} -> {:scalars 2, :scalar 0}
:scalars-comprehension {:scalars 1, :generator 0} -> {:generator 1}
:scalars-concat {:scalars 2} -> {:scalars 1}
:scalars-conj {:scalar 1, :scalars 1} -> {:scalars 1}
:scalars-contains? {:scalar 1, :scalars 1, :boolean 0} -> {:boolean 1}
:scalars-cutflip {:scalar 1, :scalars 0} -> {:scalars 0}
:scalars-cutstack {:scalar 1, :scalars 0} -> {:scalars 0}
:scalars-cycler {:scalars 1, :generator 0} -> {:generator 1}
:scalars-do*each {:scalars 1, :exec 1} -> {:exec 1}
:scalars-dup {:scalars 1} -> {:scalars 1}
:scalars-echo {:scalars 1, :generator 0} -> {:generator 1}
:scalars-echoall {:scalars 0, :generator 0} -> {:generator 1}
:scalars-empty? {:scalars 0, :boolean 0} -> {:boolean 1}
:scalars-emptyitem? {:scalars 1, :boolean 0} -> {:boolean 1}
:scalars-equal? {:scalars 2, :boolean 0} -> {:boolean 1}
:scalars-first {:scalars 1, :scalar 0} -> {:scalar 1}
:scalars-flipstack {:scalars 0} -> {:scalars 0}
:scalars-flush {:scalars 0} -> {}
:scalars-generalize {:scalars 1, :vector 0} -> {:vector 1}
:scalars-generalizeall {:scalars 0, :vector 0} -> {:vector 0}
:scalars-indexof {:scalar 1, :scalars 1} -> {:scalar 1}
:scalars-last {:scalars 1, :scalar 0} -> {:scalar 1}
:scalars-later {:scalars 1, :exec 0} -> {:exec 0}
:scalars-length {:scalars 1, :scalar 0} -> {:scalar 1}
:scalars-liftstack {:scalar 1, :scalars 0} -> {:log 1, :scalars 0}
:scalars-new {:scalars 0} -> {:scalars 1}
:scalars-notequal? {:scalars 2, :boolean 0} -> {:boolean 1}
:scalars-nth {:scalars 1, :scalar 1} -> {:scalar 1}
:scalars-occurrencesof {:scalars 1, :scalar 1} -> {:scalar 1}
:scalars-pop {:scalars 1} -> {}
:scalars-portion {:scalars 1, :scalar 2} -> {:scalars 1}
:scalars-print {:scalars 1, :print 0} -> {:print 1}
:scalars-remove {:scalars 1, :scalar 1} -> {:scalars 1}
:scalars-replace {:scalars 1, :scalar 2} -> {:scalars 1}
:scalars-replacefirst {:scalars 1, :scalar 2} -> {:scalars 1}
:scalars-rerunall {:scalars 0, :generator 0} -> {:generator 1}
:scalars-rest {:scalars 1} -> {:scalars 1}
:scalars-return {:scalars 1, :return 0} -> {:return 1}
:scalars-return-pop {:return 0} -> {:return 0}
:scalars-reverse {:scalars 1} -> {:scalars 1}
:scalars-rotate {:scalars 3} -> {:scalars 3}
:scalars-sampler {:scalars 1, :generator 0} -> {:generator 1}
:scalars-save {:ref 1, :scalars 1} -> {}
:scalars-savestack {:ref 1, :scalars 0} -> {}
:scalars-set {:scalars 1, :scalar 2} -> {:scalars 1}
:scalars-shatter {:scalars 1, :scalar 0} -> {:scalar 0}
:scalars-shove {:scalar 1, :scalars 1} -> {:scalars 0}
:scalars-stackdepth {:scalars 0, :scalar 0} -> {:scalar 1}
:scalars-store {:scalars 1} -> {}
:scalars-storestack {:scalars 0} -> {}
:scalars-swap {:scalars 2} -> {:scalars 2}
:scalars-tag {:scalars 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:scalars-take {:scalars 1, :scalar 1} -> {:scalars 1}
:scalars-yank {:scalar 1, :scalars 1} -> {:scalars 1}
:scalars-yankdup {:scalar 1, :scalars 1} -> {:scalars 1}
:scalarsign->boolean {:scalar 1, :boolean 0} -> {:boolean 1}
:scalar≤? {:scalar 2, :boolean 0} -> {:boolean 1}
:scalar≥? {:scalar 2, :boolean 0} -> {:boolean 1}
:set->code {:set 1, :code 0} -> {:code 1}
:set->tagspace {:set 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:set-againlater {:set 1, :exec 0} -> {:exec 0, :set 1}
:set-comprehension {:set 1, :generator 0} -> {:generator 1}
:set-cutflip {:scalar 1, :set 0} -> {:set 0}
:set-cutstack {:scalar 1, :set 0} -> {:set 0}
:set-cycler {:set 1, :generator 0} -> {:generator 1}
:set-difference {:set 2} -> {:set 1}
:set-dup {:set 1} -> {:set 1}
:set-echo {:set 1, :generator 0} -> {:generator 1}
:set-echoall {:set 0, :generator 0} -> {:generator 1}
:set-empty? {:set 0, :boolean 0} -> {:boolean 1}
:set-equal? {:set 2, :boolean 0} -> {:boolean 1}
:set-flipstack {:set 0} -> {:set 0}
:set-flush {:set 0} -> {}
:set-intersection {:set 2} -> {:set 1}
:set-later {:set 1, :exec 0} -> {:exec 0}
:set-liftstack {:scalar 1, :set 0} -> {:log 1, :set 0}
:set-notequal? {:set 2, :boolean 0} -> {:boolean 1}
:set-pop {:set 1} -> {}
:set-print {:set 1, :print 0} -> {:print 1}
:set-rerunall {:set 0, :generator 0} -> {:generator 1}
:set-return {:set 1, :return 0} -> {:return 1}
:set-return-pop {:return 0} -> {:return 0}
:set-rotate {:set 3} -> {:set 3}
:set-sampler {:set 1, :generator 0} -> {:generator 1}
:set-save {:ref 1, :set 1} -> {}
:set-savestack {:ref 1, :set 0} -> {}
:set-shove {:scalar 1, :set 1} -> {:set 0}
:set-stackdepth {:set 0, :scalar 0} -> {:scalar 1}
:set-store {:set 1} -> {}
:set-storestack {:set 0} -> {}
:set-subset? {:set 2, :boolean 0} -> {:boolean 1}
:set-superset? {:set 2, :boolean 0} -> {:boolean 1}
:set-swap {:set 2} -> {:set 2}
:set-tag {:set 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:set-union {:set 2} -> {:set 1}
:set-yank {:scalar 1, :set 1} -> {:set 1}
:set-yankdup {:scalar 1, :set 1} -> {:set 1}
:string->chars {:string 1, :char 0} -> {:char 0}
:string->code {:string 1, :code 0} -> {:code 1}
:string->tagspace {:string 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:string-againlater {:string 1, :exec 0} -> {:exec 0, :string 1}
:string-butlast {:string 1} -> {:string 1}
:string-comprehension {:string 1, :generator 0} -> {:generator 1}
:string-concat {:string 2} -> {:string 1}
:string-conjchar {:char 1, :string 1} -> {:string 1}
:string-contains? {:string 2, :boolean 0} -> {:boolean 1}
:string-containschar? {:string 1, :char 1, :boolean 0} -> {:boolean 1}
:string-cutflip {:scalar 1, :string 0} -> {:string 0}
:string-cutstack {:scalar 1, :string 0} -> {:string 0}
:string-cycler {:string 1, :generator 0} -> {:generator 1}
:string-dup {:string 1} -> {:string 1}
:string-echo {:string 1, :generator 0} -> {:generator 1}
:string-echoall {:string 0, :generator 0} -> {:generator 1}
:string-empty? {:string 0, :boolean 0} -> {:boolean 1}
:string-emptystring? {:string 1, :boolean 0} -> {:boolean 1}
:string-equal? {:string 2, :boolean 0} -> {:boolean 1}
:string-first {:string 1, :char 0} -> {:char 1}
:string-flipstack {:string 0} -> {:string 0}
:string-flush {:string 0} -> {}
:string-indexofchar {:string 1, :char 1, :scalar 0} -> {:scalar 1}
:string-last {:string 1, :char 0} -> {:char 1}
:string-later {:string 1, :exec 0} -> {:exec 0}
:string-length {:string 1, :scalar 0} -> {:scalar 1}
:string-liftstack {:scalar 1, :string 0} -> {:log 1, :string 0}
:string-max {:string 2} -> {:string 1}
:string-min {:string 2} -> {:string 1}
:string-notequal? {:string 2, :boolean 0} -> {:boolean 1}
:string-nth {:string 1, :scalar 1, :char 0} -> {:char 1}
:string-occurrencesofchar {:string 1, :char 1, :scalar 0} -> {:scalar 1}
:string-pop {:string 1} -> {}
:string-print {:string 1, :print 0} -> {:print 1}
:string-removechar {:string 1, :char 1} -> {:string 1}
:string-replace {:string 3} -> {:string 1}
:string-replacechar {:string 1, :char 2} -> {:string 1}
:string-replacefirst {:string 3} -> {:string 1}
:string-replacefirstchar {:string 1, :char 2} -> {:string 1}
:string-rerunall {:string 0, :generator 0} -> {:generator 1}
:string-rest {:string 1} -> {:string 1}
:string-return {:string 1, :return 0} -> {:return 1}
:string-return-pop {:return 0} -> {:return 0}
:string-reverse {:string 1} -> {:string 1}
:string-rotate {:string 3} -> {:string 3}
:string-sampler {:string 1, :generator 0} -> {:generator 1}
:string-save {:ref 1, :string 1} -> {}
:string-savestack {:ref 1, :string 0} -> {}
:string-setchar {:string 1, :char 1, :scalar 1} -> {:string 1}
:string-shatter {:string 1} -> {:string 0}
:string-shove {:scalar 1, :string 1} -> {:string 0}
:string-solid? {:string 1, :boolean 0} -> {:boolean 1}
:string-spacey? {:string 1, :boolean 0} -> {:boolean 1}
:string-splitonspaces {:string 1} -> {:string 0}
:string-stackdepth {:string 0, :scalar 0} -> {:scalar 1}
:string-store {:string 1} -> {}
:string-storestack {:string 0} -> {}
:string-substring {:string 1, :scalar 2} -> {:string 1}
:string-swap {:string 2} -> {:string 2}
:string-tag {:string 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:string-take {:string 1, :scalar 1} -> {:string 1}
:string-yank {:scalar 1, :string 1} -> {:string 1}
:string-yankdup {:scalar 1, :string 1} -> {:string 1}
:string<? {:string 2, :boolean 0} -> {:boolean 1}
:string>? {:string 2, :boolean 0} -> {:boolean 1}
:strings->code {:strings 1, :code 0} -> {:code 1}
:strings->tagspace {:strings 1, :scalar 2, :tagspace 0} -> {:tagspace 1}
:strings-againlater {:strings 1, :exec 0} -> {:exec 0, :strings 1}
:strings-build {:scalar 1, :string 0, :strings 0} -> {:string 0, :strings 1}
:strings-butlast {:strings 1} -> {:strings 1}
:strings-byexample {:strings 1, :string 0} -> {:strings 2, :string 0}
:strings-comprehension {:strings 1, :generator 0} -> {:generator 1}
:strings-concat {:strings 2} -> {:strings 1}
:strings-conj {:string 1, :strings 1} -> {:strings 1}
:strings-contains? {:string 1, :strings 1, :boolean 0} -> {:boolean 1}
:strings-cutflip {:scalar 1, :strings 0} -> {:strings 0}
:strings-cutstack {:scalar 1, :strings 0} -> {:strings 0}
:strings-cycler {:strings 1, :generator 0} -> {:generator 1}
:strings-do*each {:strings 1, :exec 1} -> {:exec 1}
:strings-dup {:strings 1} -> {:strings 1}
:strings-echo {:strings 1, :generator 0} -> {:generator 1}
:strings-echoall {:strings 0, :generator 0} -> {:generator 1}
:strings-empty? {:strings 0, :boolean 0} -> {:boolean 1}
:strings-emptyitem? {:strings 1, :boolean 0} -> {:boolean 1}
:strings-equal? {:strings 2, :boolean 0} -> {:boolean 1}
:strings-first {:strings 1, :string 0} -> {:string 1}
:strings-flipstack {:strings 0} -> {:strings 0}
:strings-flush {:strings 0} -> {}
:strings-generalize {:strings 1, :vector 0} -> {:vector 1}
:strings-generalizeall {:strings 0, :vector 0} -> {:vector 0}
:strings-indexof {:string 1, :strings 1, :scalar 0} -> {:scalar 1}
:strings-last {:strings 1, :string 0} -> {:string 1}
:strings-later {:strings 1, :exec 0} -> {:exec 0}
:strings-length {:strings 1, :scalar 0} -> {:scalar 1}
:strings-liftstack {:scalar 1, :strings 0} -> {:log 1, :strings 0}
:strings-new {:strings 0} -> {:strings 1}
:strings-notequal? {:strings 2, :boolean 0} -> {:boolean 1}
:strings-nth {:strings 1, :scalar 1, :string 0} -> {:string 1}
:strings-occurrencesof {:strings 1, :string 1, :scalar 0} -> {:scalar 1}
:strings-pop {:strings 1} -> {}
:strings-portion {:strings 1, :scalar 2} -> {:strings 1}
:strings-print {:strings 1, :print 0} -> {:print 1}
:strings-remove {:strings 1, :string 1} -> {:strings 1}
:strings-replace {:strings 1, :string 2} -> {:strings 1}
:strings-replacefirst {:strings 1, :string 2} -> {:strings 1}
:strings-rerunall {:strings 0, :generator 0} -> {:generator 1}
:strings-rest {:strings 1} -> {:strings 1}
:strings-return {:strings 1, :return 0} -> {:return 1}
:strings-return-pop {:return 0} -> {:return 0}
:strings-reverse {:strings 1} -> {:strings 1}
:strings-rotate {:strings 3} -> {:strings 3}
:strings-sampler {:strings 1, :generator 0} -> {:generator 1}
:strings-save {:ref 1, :strings 1} -> {}
:strings-savestack {:ref 1, :strings 0} -> {}
:strings-set {:strings 1, :string 1, :scalar 1} -> {:strings 1}
:strings-shatter {:strings 1, :string 0} -> {:string 0}
:strings-shove {:scalar 1, :strings 1} -> {:strings 0}
:strings-stackdepth {:strings 0, :scalar 0} -> {:scalar 1}
:strings-store {:strings 1} -> {}
:strings-storestack {:strings 0} -> {}
:strings-swap {:strings 2} -> {:strings 2}
:strings-tag {:strings 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:strings-take {:strings 1, :scalar 1} -> {:strings 1}
:strings-yank {:scalar 1, :strings 1} -> {:strings 1}
:strings-yankdup {:scalar 1, :strings 1} -> {:strings 1}
:string≤? {:string 2, :boolean 0} -> {:boolean 1}
:string≥? {:string 2, :boolean 0} -> {:boolean 1}
:tagspace->code {:tagspace 1, :code 0} -> {:code 1}
:tagspace-againlater {:tagspace 1, :exec 0} -> {:exec 0, :tagspace 1}
:tagspace-comprehension {:tagspace 1, :generator 0} -> {:generator 1}
:tagspace-count {:tagspace 1, :exec 0} -> {:exec 1}
:tagspace-cutflip {:scalar 1, :tagspace 0} -> {:tagspace 0}
:tagspace-cutstack {:scalar 1, :tagspace 0} -> {:tagspace 0}
:tagspace-cycler {:tagspace 1, :generator 0} -> {:generator 1}
:tagspace-dup {:tagspace 1} -> {:tagspace 1}
:tagspace-echo {:tagspace 1, :generator 0} -> {:generator 1}
:tagspace-echoall {:tagspace 0, :generator 0} -> {:generator 1}
:tagspace-empty? {:tagspace 0, :boolean 0} -> {:boolean 1}
:tagspace-equal? {:tagspace 2, :boolean 0} -> {:boolean 1}
:tagspace-flipstack {:tagspace 0} -> {:tagspace 0}
:tagspace-flush {:tagspace 0} -> {}
:tagspace-keys {:tagspace 1, :exec 0} -> {:exec 1}
:tagspace-later {:tagspace 1, :exec 0} -> {:exec 0}
:tagspace-liftstack {:scalar 1, :tagspace 0} -> {:log 1, :tagspace 0}
:tagspace-lookup {:scalar 1, :tagspace 1, :exec 0} -> {:exec 1, :tagspace 1}
:tagspace-lookupscalars {:scalars 1, :tagspace 1, :exec 0} -> {:exec 1, :tagspace 1}
:tagspace-lookupvector {:vector 1, :tagspace 1, :exec 0} -> {:exec 1, :tagspace 1}
:tagspace-max {:tagspace 1, :exec 0} -> {:exec 1}
:tagspace-merge {:tagspace 2} -> {:tagspace 1}
:tagspace-min {:tagspace 1, :exec 0} -> {:exec 1}
:tagspace-new {:tagspace 0} -> {:tagspace 1}
:tagspace-normalize {:tagspace 1} -> {:tagspace 1}
:tagspace-notequal? {:tagspace 2, :boolean 0} -> {:boolean 1}
:tagspace-offset {:tagspace 1, :scalar 1} -> {:tagspace 1}
:tagspace-pop {:tagspace 1} -> {}
:tagspace-print {:tagspace 1, :print 0} -> {:print 1}
:tagspace-rerunall {:tagspace 0, :generator 0} -> {:generator 1}
:tagspace-return {:tagspace 1, :return 0} -> {:return 1}
:tagspace-return-pop {:return 0} -> {:return 0}
:tagspace-rotate {:tagspace 3} -> {:tagspace 3}
:tagspace-sampler {:tagspace 1, :generator 0} -> {:generator 1}
:tagspace-save {:ref 1, :tagspace 1} -> {}
:tagspace-savestack {:ref 1, :tagspace 0} -> {}
:tagspace-scale {:tagspace 1, :scalar 1} -> {:tagspace 1}
:tagspace-shove {:scalar 1, :tagspace 1} -> {:tagspace 0}
:tagspace-split {:tagspace 1, :scalar 1, :exec 0} -> {:exec 1}
:tagspace-stackdepth {:tagspace 0, :scalar 0} -> {:scalar 1}
:tagspace-store {:tagspace 1} -> {}
:tagspace-storestack {:tagspace 0} -> {}
:tagspace-swap {:tagspace 2} -> {:tagspace 2}
:tagspace-tag {:tagspace 2, :scalar 1} -> {:tagspace 1}
:tagspace-tidy {:tagspace 1, :scalar 2} -> {:tagspace 1}
:tagspace-values {:tagspace 1, :exec 0} -> {:exec 1}
:tagspace-yank {:scalar 1, :tagspace 1} -> {:tagspace 1}
:tagspace-yankdup {:scalar 1, :tagspace 1} -> {:tagspace 1}
:vector->code {:vector 1, :code 0} -> {:code 1}
:vector->set {:vector 1, :set 0} -> {:set 1}
:vector-againlater {:vector 1, :exec 0} -> {:exec 0, :vector 1}
:vector-butlast {:vector 1} -> {:vector 1}
:vector-byexample {:vector 1, :code 0} -> {:vector 2, :code 0}
:vector-comprehension {:vector 1, :generator 0} -> {:generator 1}
:vector-concat {:vector 2} -> {:vector 1}
:vector-conj {:code 1, :vector 1} -> {:vector 1}
:vector-contains? {:code 1, :vector 1, :boolean 0} -> {:boolean 1}
:vector-cutflip {:scalar 1, :vector 0} -> {:vector 0}
:vector-cutstack {:scalar 1, :vector 0} -> {:vector 0}
:vector-cycler {:vector 1, :generator 0} -> {:generator 1}
:vector-do*each {:vector 1, :exec 1} -> {:exec 1}
:vector-dup {:vector 1} -> {:vector 1}
:vector-echo {:vector 1, :generator 0} -> {:generator 1}
:vector-echoall {:vector 0, :generator 0} -> {:generator 1}
:vector-empty? {:vector 0, :boolean 0} -> {:boolean 1}
:vector-emptyitem? {:vector 1, :boolean 0} -> {:boolean 1}
:vector-equal? {:vector 2, :boolean 0} -> {:boolean 1}
:vector-first {:vector 1, :code 0} -> {:code 1}
:vector-flipstack {:vector 0} -> {:vector 0}
:vector-flush {:vector 0} -> {}
:vector-indexof {:code 1, :vector 1, :scalar 0} -> {:scalar 1}
:vector-last {:vector 1, :code 0} -> {:code 1}
:vector-later {:vector 1, :exec 0} -> {:exec 0}
:vector-length {:vector 1, :scalar 0} -> {:scalar 1}
:vector-liftstack {:scalar 1, :vector 0} -> {:log 1, :vector 0}
:vector-new {:vector 0} -> {:vector 1}
:vector-notequal? {:vector 2, :boolean 0} -> {:boolean 1}
:vector-nth {:vector 1, :scalar 1, :code 0} -> {:code 1}
:vector-occurrencesof {:vector 1, :code 1, :scalar 0} -> {:scalar 1}
:vector-pop {:vector 1} -> {}
:vector-portion {:vector 1, :scalar 2} -> {:vector 1}
:vector-print {:vector 1, :print 0} -> {:print 1}
:vector-refilter {:vector 1, :exec 0} -> {:exec 1}
:vector-refilterall {:vector 0, :exec 0} -> {:exec 0}
:vector-remove {:vector 1, :code 1} -> {:vector 1}
:vector-replace {:vector 1, :code 2} -> {:vector 1}
:vector-replacefirst {:vector 1, :code 2} -> {:vector 1}
:vector-rerunall {:vector 0, :generator 0} -> {:generator 1}
:vector-rest {:vector 1} -> {:vector 1}
:vector-return {:vector 1, :return 0} -> {:return 1}
:vector-return-pop {:return 0} -> {:return 0}
:vector-reverse {:vector 1} -> {:vector 1}
:vector-rotate {:vector 3} -> {:vector 3}
:vector-sampler {:vector 1, :generator 0} -> {:generator 1}
:vector-save {:ref 1, :vector 1} -> {}
:vector-savestack {:ref 1, :vector 0} -> {}
:vector-set {:vector 1, :code 1, :scalar 1} -> {:vector 1}
:vector-shatter {:vector 1, :code 0} -> {:code 0}
:vector-shove {:scalar 1, :vector 1} -> {:vector 0}
:vector-stackdepth {:vector 0, :scalar 0} -> {:scalar 1}
:vector-store {:vector 1} -> {}
:vector-storestack {:vector 0} -> {}
:vector-swap {:vector 2} -> {:vector 2}
:vector-tag {:vector 1, :tagspace 1, :scalar 1} -> {:tagspace 1}
:vector-take {:vector 1, :scalar 1} -> {:vector 1}
:vector-yank {:scalar 1, :vector 1} -> {:vector 1}
:vector-yankdup {:scalar 1, :vector 1} -> {:vector 1}