Vaguery
commented
8 years ago There seem to be some things missing. For example, :x-return-pop has no needs, but it should.
:boolean-2bittable {:scalar 1} {:booleans 1}
:boolean-3bittable {:scalar 1} {:booleans 1}
:boolean->code {:boolean 1} {:code 1}
:boolean->float {:boolean 1} {:scalar 1}
:boolean->integer {:boolean 1} {:scalar 1}
:boolean->set {:boolean 1} {:set 1}
:boolean->signedfloat {:boolean 1} {:scalar 1}
:boolean->signedint {:boolean 1} {:scalar 1}
:boolean->string {:boolean 1} {:string 1}
:boolean-againlater {:boolean 1} {: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-as-set {:boolean 1} {:set 1}
:boolean-conj-set {:boolean 1, :set 1} {:set 1}
:boolean-cutflip {:scalar 1} {}
:boolean-cutstack {:scalar 1} {}
:boolean-dup {:boolean 1} {:boolean 1}
:boolean-echo {:boolean 1} {:generator 1}
:boolean-echoall {} {:generator 1}
:boolean-empty? {} {:boolean 1}
:boolean-equal? {:boolean 2} {:boolean 1}
:boolean-faircoin {} {:boolean 1}
:boolean-flipstack {} {}
:boolean-flush {} {}
:boolean-in-set? {:boolean 1, :set 1} {:boolean 1}
:boolean-intoset {:boolean 1, :set 1} {:set 1}
:boolean-later {:boolean 1} {}
:boolean-liftstack {:scalar 1} {:error 1}
:boolean-not {:boolean 1} {:boolean 1}
:boolean-notequal? {:boolean 2} {:boolean 1}
:boolean-or {:boolean 2} {:boolean 1}
:boolean-pop {} {}
:boolean-print {:boolean 1} {:print 1}
:boolean-rerunall {} {:generator 1}
:boolean-return {:boolean 1} {:return 1}
:boolean-return-pop {} {}
:boolean-rotate {:boolean 3} {:boolean 3}
:boolean-save {:ref 1, :boolean 1} {}
:boolean-savestack {:ref 1} {}
:boolean-shove {:scalar 1, :boolean 1} {}
:boolean-stackdepth {} {:scalar 1}
:boolean-store {:boolean 1} {}
:boolean-storestack {} {}
:boolean-swap {:boolean 2} {:boolean 2}
:boolean-tag {:boolean 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:boolean-tagstack {} {: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 1}
:booleans->set {:booleans 1} {:set 1}
:booleans->tagspace {:booleans 1, :scalar 2} {:tagspace 1}
:booleans-againlater {:booleans 1} {:booleans 1}
:booleans-as-set {:booleans 1} {:set 1}
:booleans-build {:scalar 1} {:booleans 1}
:booleans-butlast {:booleans 1} {:booleans 1}
:booleans-byexample {:booleans 1} {:booleans 2}
:booleans-comprehension {:booleans 1} {:generator 1}
:booleans-concat {:booleans 2} {:booleans 1}
:booleans-conj {:boolean 1, :booleans 1} {:booleans 1}
:booleans-conj-set {:booleans 1, :set 1} {:set 1}
:booleans-contains? {:boolean 1, :booleans 1} {:boolean 1}
:booleans-cutflip {:scalar 1} {}
:booleans-cutstack {:scalar 1} {}
:booleans-cycler {:booleans 1} {:generator 1}
:booleans-cyclevector {:scalar 2} {:booleans 1}
:booleans-distinct {:booleans 1} {:booleans 1}
:booleans-do*each {:booleans 1, :exec 1} {:exec 1}
:booleans-dup {:booleans 1} {:booleans 1}
:booleans-echo {:booleans 1} {:generator 1}
:booleans-echoall {} {:generator 1}
:booleans-empty? {} {:boolean 1}
:booleans-emptyitem? {:booleans 1} {:boolean 1}
:booleans-equal? {:booleans 2} {:boolean 1}
:booleans-fillvector {:boolean 1, :scalar 2} {:booleans 1}
:booleans-first {:booleans 1} {:boolean 1}
:booleans-flipstack {} {}
:booleans-flush {} {}
:booleans-generalize {:booleans 1} {:vector 1}
:booleans-generalizeall {} {}
:booleans-in-set? {:booleans 1, :set 1} {:boolean 1}
:booleans-indexof {:boolean 1, :booleans 1} {:scalar 1}
:booleans-intoset {:booleans 1, :set 1} {:set 1}
:booleans-items {:booleans 1} {:exec 1}
:booleans-last {:booleans 1} {:boolean 1}
:booleans-later {:booleans 1} {}
:booleans-length {:booleans 1} {:scalar 1}
:booleans-liftstack {:scalar 1} {:error 1}
:booleans-new {} {:booleans 1}
:booleans-notequal? {:booleans 2} {:boolean 1}
:booleans-nth {:booleans 1, :scalar 1} {:boolean 1}
:booleans-occurrencesof {:booleans 1, :boolean 1} {:scalar 1}
:booleans-pop {} {}
:booleans-portion {:booleans 1, :scalar 2} {:booleans 1}
:booleans-print {:booleans 1} {:print 1}
:booleans-pt-crossover {:booleans 2, :scalar 2} {:booleans 2}
: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 {} {:generator 1}
:booleans-rest {:booleans 1} {:booleans 1}
:booleans-return {:booleans 1} {:return 1}
:booleans-return-pop {} {}
:booleans-reverse {:booleans 1} {:booleans 1}
:booleans-rotate {:booleans 3} {:booleans 3}
:booleans-sampler {:booleans 1} {:generator 1}
:booleans-save {:ref 1, :booleans 1} {}
:booleans-savestack {:ref 1} {}
:booleans-set {:booleans 1, :boolean 1, :scalar 1} {:booleans 1}
:booleans-shatter {:booleans 1} {}
:booleans-shove {:scalar 1, :booleans 1} {}
:booleans-stackdepth {} {:scalar 1}
:booleans-store {:booleans 1} {}
:booleans-storestack {} {}
:booleans-swap {:booleans 2} {:booleans 2}
:booleans-tag {:booleans 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:booleans-tagstack {} {:tagspace 1}
:booleans-take {:booleans 1, :scalar 1} {:booleans 1}
:booleans-vfilter {:booleans 2} {:booleans 1}
:booleans-vremove {:booleans 2} {:booleans 1}
:booleans-vsplit {:booleans 2} {:exec 1}
:booleans-yank {:scalar 1, :booleans 1} {:booleans 1}
:booleans-yankdup {:scalar 1, :booleans 1} {:booleans 1}
:char->code {:char 1} {:code 1}
:char->integer {:char 1} {:scalar 1}
:char->set {:char 1} {:set 1}
:char->string {:char 1} {:string 1}
:char-againlater {:char 1} {:char 1}
:char-as-set {:char 1} {:set 1}
:char-conj-set {:char 1, :set 1} {:set 1}
:char-cutflip {:scalar 1} {}
:char-cutstack {:scalar 1} {}
:char-digit? {:char 1} {:boolean 1}
:char-dup {:char 1} {:char 1}
:char-echo {:char 1} {:generator 1}
:char-echoall {} {:generator 1}
:char-empty? {} {:boolean 1}
:char-equal? {:char 2} {:boolean 1}
:char-flipstack {} {}
:char-flush {} {}
:char-in-set? {:char 1, :set 1} {:boolean 1}
:char-intoset {:char 1, :set 1} {:set 1}
:char-later {:char 1} {}
:char-letter? {:char 1} {:boolean 1}
:char-liftstack {:scalar 1} {:error 1}
:char-lowercase? {:char 1} {:boolean 1}
:char-max {:char 2} {:char 1}
:char-min {:char 2} {:char 1}
:char-notequal? {:char 2} {:boolean 1}
:char-pop {} {}
:char-print {:char 1} {:print 1}
:char-rerunall {} {:generator 1}
:char-return {:char 1} {:return 1}
:char-return-pop {} {}
:char-rotate {:char 3} {:char 3}
:char-save {:ref 1, :char 1} {}
:char-savestack {:ref 1} {}
:char-shove {:scalar 1, :char 1} {}
:char-stackdepth {} {:scalar 1}
:char-store {:char 1} {}
:char-storestack {} {}
:char-swap {:char 2} {:char 2}
:char-tag {:char 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:char-tagstack {} {:tagspace 1}
:char-uppercase? {:char 1} {:boolean 1}
:char-whitespace? {:char 1} {:boolean 1}
:char-yank {:scalar 1, :char 1} {:char 1}
:char-yankdup {:scalar 1, :char 1} {:char 1}
:char<? {:char 2} {:boolean 1}
:char>? {:char 2} {:boolean 1}
:chars->code {:chars 1} {:code 1}
:chars->set {:chars 1} {:set 1}
:chars->tagspace {:chars 1, :scalar 2} {:tagspace 1}
:chars-againlater {:chars 1} {:chars 1}
:chars-as-set {:chars 1} {:set 1}
:chars-build {:scalar 1} {:chars 1}
:chars-butlast {:chars 1} {:chars 1}
:chars-byexample {:chars 1} {:chars 2}
:chars-comprehension {:chars 1} {:generator 1}
:chars-concat {:chars 2} {:chars 1}
:chars-conj {:char 1, :chars 1} {:chars 1}
:chars-conj-set {:chars 1, :set 1} {:set 1}
:chars-contains? {:char 1, :chars 1} {:boolean 1}
:chars-cutflip {:scalar 1} {}
:chars-cutstack {:scalar 1} {}
:chars-cycler {:chars 1} {:generator 1}
:chars-cyclevector {:scalar 2} {:chars 1}
:chars-distinct {:chars 1} {:chars 1}
:chars-do*each {:chars 1, :exec 1} {:exec 1}
:chars-dup {:chars 1} {:chars 1}
:chars-echo {:chars 1} {:generator 1}
:chars-echoall {} {:generator 1}
:chars-empty? {} {:boolean 1}
:chars-emptyitem? {:chars 1} {:boolean 1}
:chars-equal? {:chars 2} {:boolean 1}
:chars-fillvector {:char 1, :scalar 2} {:chars 1}
:chars-first {:chars 1} {:char 1}
:chars-flipstack {} {}
:chars-flush {} {}
:chars-generalize {:chars 1} {:vector 1}
:chars-generalizeall {} {}
:chars-in-set? {:chars 1, :set 1} {:boolean 1}
:chars-indexof {:char 1, :chars 1} {:scalar 1}
:chars-intoset {:chars 1, :set 1} {:set 1}
:chars-items {:chars 1} {:exec 1}
:chars-last {:chars 1} {:char 1}
:chars-later {:chars 1} {}
:chars-length {:chars 1} {:scalar 1}
:chars-liftstack {:scalar 1} {:error 1}
:chars-new {} {:chars 1}
:chars-notequal? {:chars 2} {:boolean 1}
:chars-nth {:chars 1, :scalar 1} {:char 1}
:chars-occurrencesof {:chars 1, :char 1} {:scalar 1}
:chars-pop {} {}
:chars-portion {:chars 1, :scalar 2} {:chars 1}
:chars-print {:chars 1} {:print 1}
:chars-pt-crossover {:chars 2, :scalar 2} {:chars 2}
: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 {} {:generator 1}
:chars-rest {:chars 1} {:chars 1}
:chars-return {:chars 1} {:return 1}
:chars-return-pop {} {}
:chars-reverse {:chars 1} {:chars 1}
:chars-rotate {:chars 3} {:chars 3}
:chars-sampler {:chars 1} {:generator 1}
:chars-save {:ref 1, :chars 1} {}
:chars-savestack {:ref 1} {}
:chars-set {:chars 1, :char 1, :scalar 1} {:chars 1}
:chars-shatter {:chars 1} {}
:chars-shove {:scalar 1, :chars 1} {}
:chars-stackdepth {} {:scalar 1}
:chars-store {:chars 1} {}
:chars-storestack {} {}
:chars-swap {:chars 2} {:chars 2}
:chars-tag {:chars 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:chars-tagstack {} {:tagspace 1}
:chars-take {:chars 1, :scalar 1} {:chars 1}
:chars-vfilter {:chars 2} {:chars 1}
:chars-vremove {:chars 2} {:chars 1}
:chars-vsplit {:chars 2} {:exec 1}
:chars-yank {:scalar 1, :chars 1} {:chars 1}
:chars-yankdup {:scalar 1, :chars 1} {:chars 1}
:char≤? {:char 2} {:boolean 1}
:char≥? {:char 2} {:boolean 1}
:code->set {:code 1} {:set 1}
:code->string {:code 1} {:string 1}
:code-againlater {:code 1} {:code 1}
:code-append {:code 2} {:code 1}
:code-as-set {:code 1} {:set 1}
:code-atom? {:code 1} {:boolean 1}
:code-comprehension {:code 1} {:generator 1}
:code-conj-set {:code 1, :set 1} {:set 1}
:code-cons {:code 2} {:code 1}
:code-container {:code 2} {:code 1}
:code-contains? {:code 2} {:boolean 1}
:code-cutflip {:scalar 1} {}
:code-cutstack {:scalar 1} {}
:code-cycler {:code 1} {:generator 1}
:code-do {:code 1} {:exec 1}
:code-do* {:code 1} {:exec 1}
:code-do*count {:code 1, :scalar 1} {:exec 1}
:code-do*range {:code 1, :scalar 2} {:exec 1}
:code-do*times {:code 1, :scalar 1} {:exec 1}
:code-drop {:code 1, :scalar 1} {:code 1}
:code-dup {:code 1} {:code 1}
:code-echo {:code 1} {:generator 1}
:code-echoall {} {:generator 1}
:code-empty? {} {:boolean 1}
:code-equal? {:code 2} {:boolean 1}
:code-extract {:code 1, :scalar 1} {:code 1}
:code-first {:code 1} {:code 1}
:code-flipstack {} {}
:code-flush {} {}
:code-if {:code 2, :boolean 1} {:exec 1}
:code-in-set? {:code 1, :set 1} {:boolean 1}
:code-insert {:code 2, :scalar 1} {:code 1}
:code-intoset {:code 1, :set 1} {:set 1}
:code-later {:code 1} {}
:code-length {:code 1} {:scalar 1}
:code-liftstack {:scalar 1} {:error 1}
:code-list {:code 2} {:code 1}
:code-map {:code 1, :exec 1} {:exec 1}
:code-member? {:code 2} {:boolean 1}
:code-noop
:code-notequal? {:code 2} {:boolean 1}
:code-nth {:code 1, :scalar 1} {:code 1}
:code-null? {:code 1} {:boolean 1}
:code-points {:code 1} {:scalar 1}
:code-pop {} {}
:code-position {:code 2} {:scalar 1}
:code-print {:code 1} {:print 1}
:code-quote {:exec 1} {:code 1}
:code-reduce {:code 1, :exec 1} {:exec 1}
:code-rerunall {} {:generator 1}
:code-rest {:code 1} {:code 1}
:code-return {:code 1} {:return 1}
:code-return-pop {} {}
:code-rotate {:code 3} {:code 3}
:code-sampler {:code 1} {:generator 1}
:code-save {:ref 1, :code 1} {}
:code-savestack {:ref 1} {}
:code-shove {:scalar 1, :code 1} {}
:code-size {:code 1} {:scalar 1}
:code-stackdepth {} {:scalar 1}
:code-store {:code 1} {}
:code-storestack {} {}
:code-subst {:code 3} {:code 1}
:code-swap {:code 2} {:code 2}
:code-tag {:code 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:code-tagstack {} {: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 1}
:complex->set {:complex 1} {:set 1}
:complex-add {:complex 2} {:complex 1, :error 1}
:complex-againlater {:complex 1} {:complex 1}
:complex-as-set {:complex 1} {:set 1}
:complex-conj-set {:complex 1, :set 1} {:set 1}
:complex-conjugate {:complex 1} {:complex 1}
:complex-cutflip {:scalar 1} {}
:complex-cutstack {:scalar 1} {}
:complex-divide {:complex 2} {:complex 1, :error 1}
:complex-dup {:complex 1} {:complex 1}
:complex-echo {:complex 1} {:generator 1}
:complex-echoall {} {:generator 1}
:complex-empty? {} {:boolean 1}
:complex-equal? {:complex 2} {:boolean 1}
:complex-flipstack {} {}
:complex-flush {} {}
:complex-in-set? {:complex 1, :set 1} {:boolean 1}
:complex-infinite? {:complex 1} {:boolean 1}
:complex-intoset {:complex 1, :set 1} {:set 1}
:complex-later {:complex 1} {}
:complex-liftstack {:scalar 1} {:error 1}
:complex-multiply {:complex 2} {:complex 1, :error 1}
:complex-norm {:complex 1} {:scalar 1}
:complex-notequal? {:complex 2} {:boolean 1}
:complex-parts {:complex 1} {:exec 1}
:complex-pop {} {}
:complex-print {:complex 1} {:print 1}
:complex-reciprocal {:complex 1} {:complex 1, :error 1}
:complex-rerunall {} {:generator 1}
:complex-return {:complex 1} {:return 1}
:complex-return-pop {} {}
:complex-rotate {:complex 3} {:complex 3}
:complex-save {:ref 1, :complex 1} {}
:complex-savestack {:ref 1} {}
:complex-scale {:scalar 1, :complex 1} {:complex 1}
:complex-shift {:scalar 1, :complex 1} {:complex 1}
:complex-shove {:scalar 1, :complex 1} {}
:complex-stackdepth {} {:scalar 1}
:complex-store {:complex 1} {}
:complex-storestack {} {}
:complex-subtract {:complex 2} {:complex 1, :error 1}
:complex-swap {:complex 2} {:complex 2}
:complex-tag {:complex 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:complex-tagstack {} {:tagspace 1}
:complex-yank {:scalar 1, :complex 1} {:complex 1}
:complex-yankdup {:scalar 1, :complex 1} {:complex 1}
:complex-zero {} {:complex 1}
:complexes->code {:complexes 1} {:code 1}
:complexes->set {:complexes 1} {:set 1}
:complexes->tagspace {:complexes 1, :scalar 2} {:tagspace 1}
:complexes-againlater {:complexes 1} {:complexes 1}
:complexes-as-set {:complexes 1} {:set 1}
:complexes-build {:scalar 1} {:complexes 1}
:complexes-butlast {:complexes 1} {:complexes 1}
:complexes-byexample {:complexes 1} {:complexes 2}
:complexes-comprehension {:complexes 1} {:generator 1}
:complexes-concat {:complexes 2} {:complexes 1}
:complexes-conj {:complex 1, :complexes 1} {:complexes 1}
:complexes-conj-set {:complexes 1, :set 1} {:set 1}
:complexes-contains? {:complex 1, :complexes 1} {:boolean 1}
:complexes-cutflip {:scalar 1} {}
:complexes-cutstack {:scalar 1} {}
:complexes-cycler {:complexes 1} {:generator 1}
:complexes-cyclevector {:scalar 2} {:complexes 1}
:complexes-distinct {:complexes 1} {:complexes 1}
:complexes-do*each {:complexes 1, :exec 1} {:exec 1}
:complexes-dup {:complexes 1} {:complexes 1}
:complexes-echo {:complexes 1} {:generator 1}
:complexes-echoall {} {:generator 1}
:complexes-empty? {} {:boolean 1}
:complexes-emptyitem? {:complexes 1} {:boolean 1}
:complexes-equal? {:complexes 2} {:boolean 1}
:complexes-fillvector {:complex 1, :scalar 2} {:complexes 1}
:complexes-first {:complexes 1} {:complex 1}
:complexes-flipstack {} {}
:complexes-flush {} {}
:complexes-generalize {:complexes 1} {:vector 1}
:complexes-generalizeall {} {}
:complexes-in-set? {:complexes 1, :set 1} {:boolean 1}
:complexes-indexof {:complex 1, :complexes 1} {:scalar 1}
:complexes-intoset {:complexes 1, :set 1} {:set 1}
:complexes-items {:complexes 1} {:exec 1}
:complexes-last {:complexes 1} {:complex 1}
:complexes-later {:complexes 1} {}
:complexes-length {:complexes 1} {:scalar 1}
:complexes-liftstack {:scalar 1} {:error 1}
:complexes-new {} {:complexes 1}
:complexes-notequal? {:complexes 2} {:boolean 1}
:complexes-nth {:complexes 1, :scalar 1} {:complex 1}
:complexes-occurrencesof {:complexes 1, :complex 1} {:scalar 1}
:complexes-pop {} {}
:complexes-portion {:complexes 1, :scalar 2} {:complexes 1}
:complexes-print {:complexes 1} {:print 1}
:complexes-pt-crossover {:complexes 2, :scalar 2} {:complexes 2}
: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 {} {:generator 1}
:complexes-rest {:complexes 1} {:complexes 1}
:complexes-return {:complexes 1} {:return 1}
:complexes-return-pop {} {}
:complexes-reverse {:complexes 1} {:complexes 1}
:complexes-rotate {:complexes 3} {:complexes 3}
:complexes-sampler {:complexes 1} {:generator 1}
:complexes-save {:ref 1, :complexes 1} {}
:complexes-savestack {:ref 1} {}
:complexes-set {:complexes 1, :complex 1, :scalar 1} {:complexes 1}
:complexes-shatter {:complexes 1} {}
:complexes-shove {:scalar 1, :complexes 1} {}
:complexes-stackdepth {} {:scalar 1}
:complexes-store {:complexes 1} {}
:complexes-storestack {} {}
:complexes-swap {:complexes 2} {:complexes 2}
:complexes-tag {:complexes 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:complexes-tagstack {} {:tagspace 1}
:complexes-take {:complexes 1, :scalar 1} {:complexes 1}
:complexes-vfilter {:complexes 2} {:complexes 1}
:complexes-vremove {:complexes 2} {:complexes 1}
:complexes-vsplit {:complexes 2} {:exec 1}
:complexes-yank {:scalar 1, :complexes 1} {:complexes 1}
:complexes-yankdup {:scalar 1, :complexes 1} {:complexes 1}
:error-empty? {} {:boolean 1}
:error-stackdepth {} {:scalar 1}
:exec->set {:exec 1} {:set 1}
:exec->string {:exec 1} {:string 1}
:exec-againlater {:exec 1} {:exec 1}
:exec-as-set {:exec 1} {:set 1}
:exec-comprehension {:exec 1} {:generator 1}
:exec-conj-set {:exec 1, :set 1} {:set 1}
:exec-cutflip {:scalar 1} {}
:exec-cutstack {:scalar 1} {}
:exec-cycler {:exec 1} {: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 1}
:exec-echoall {} {:generator 1}
:exec-empty? {} {:boolean 1}
:exec-equal? {:exec 2} {:boolean 1}
:exec-flipstack {} {}
:exec-flush {} {}
:exec-if {:boolean 1, :exec 2} {:exec 1}
:exec-in-set? {:exec 1, :set 1} {:boolean 1}
:exec-intoset {:exec 1, :set 1} {:set 1}
:exec-k {:exec 2} {:exec 1}
:exec-later {:exec 1} {}
:exec-laterloop {:exec 1} {}
:exec-liftstack {:scalar 1} {:error 1}
:exec-noop
:exec-notequal? {:exec 2} {:boolean 1}
:exec-pop {} {}
:exec-print {:exec 1} {:print 1}
:exec-rerunall {} {:generator 1}
:exec-return {:exec 1} {:return 1}
:exec-return-pop {} {}
:exec-rotate {:exec 3} {:exec 3}
:exec-s {:exec 3} {:exec 3}
:exec-sampler {:exec 1} {:generator 1}
:exec-save {:ref 1, :exec 1} {}
:exec-savestack {:ref 1} {}
:exec-shove {:scalar 1, :exec 1} {}
:exec-stackdepth {} {:scalar 1}
:exec-store {:exec 1} {}
:exec-storestack {} {}
: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, :error 1}
:exec-tagstack {} {:tagspace 1}
:exec-when {:exec 1, :boolean 1} {:exec 1}
:exec-while {:exec 1, :boolean 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, :error 1}
:generator->code {:generator 1} {:code 1}
:generator-again {:generator 1} {:exec 1}
:generator-againlater {:generator 1} {:generator 1}
:generator-counter {:scalar 1} {:generator 1}
:generator-cutflip {:scalar 1} {}
:generator-cutstack {:scalar 1} {}
:generator-dup {:generator 1} {:generator 1}
:generator-echo {:generator 1} {:generator 1}
:generator-echoall {} {:generator 1}
:generator-empty? {} {:boolean 1}
:generator-flipstack {} {}
:generator-flush {} {}
:generator-jumpsome {:generator 1, :scalar 1} {:generator 1}
:generator-later {:generator 1} {}
:generator-liftstack {:scalar 1} {:error 1}
:generator-next {:generator 1} {:exec 1}
:generator-pop {} {}
:generator-rerunall {} {:generator 1}
:generator-reset {:generator 1} {:generator 1}
:generator-return {:generator 1} {:return 1}
:generator-return-pop {} {}
:generator-rotate {:generator 3} {:generator 3}
:generator-save {:ref 1, :generator 1} {}
:generator-savestack {:ref 1} {}
:generator-shove {:scalar 1, :generator 1} {}
:generator-stackdepth {} {:scalar 1}
:generator-stepper {:scalar 2} {:generator 1}
:generator-store {:generator 1} {}
:generator-storestack {} {}
:generator-swap {:generator 2} {:generator 2}
:generator-tag {:generator 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:generator-tagstack {} {:tagspace 1}
:generator-totalistic3 {:scalar 1} {: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, :error 1}
:interval->code {:interval 1} {:code 1}
:interval->set {:interval 1} {:set 1}
:interval-add {:interval 2} {:interval 1}
:interval-againlater {:interval 1} {:interval 1}
:interval-as-set {:interval 1} {:set 1}
:interval-conj-set {:interval 1, :set 1} {:set 1}
:interval-crossover {:interval 2} {:exec 1}
:interval-cutflip {:scalar 1} {}
:interval-cutstack {:scalar 1} {}
:interval-divide {:interval 2} {:exec 1}
:interval-dup {:interval 1} {:interval 1}
:interval-echo {:interval 1} {:generator 1}
:interval-echoall {} {:generator 1}
:interval-empty? {:interval 1} {:boolean 1}
:interval-equal? {:interval 2} {:boolean 1}
:interval-flipstack {} {}
:interval-flush {} {}
:interval-hull {:interval 2} {:interval 1}
:interval-in-set? {:interval 1, :set 1} {:boolean 1}
:interval-include? {:interval 1, :scalar 1} {:boolean 1}
:interval-intersection {:interval 2} {:interval 1}
:interval-intoset {:interval 1, :set 1} {:set 1}
:interval-later {:interval 1} {}
:interval-liftstack {:scalar 1} {:error 1}
:interval-max {:interval 1} {:scalar 1}
:interval-min {:interval 1} {:scalar 1}
:interval-multiply {:interval 2} {:interval 1}
:interval-new {:scalar 2} {:interval 1}
:interval-newopen {:scalar 2} {:interval 1}
:interval-notequal? {:interval 2} {:boolean 1}
:interval-overlap? {:interval 2} {:boolean 1}
:interval-pop {} {}
:interval-print {:interval 1} {:print 1}
:interval-rebracket {:boolean 2, :interval 1} {:interval 1}
:interval-recenter {:interval 1} {:interval 1}
:interval-reciprocal {:interval 1} {:exec 1}
:interval-reflect {:interval 1} {:interval 1}
:interval-rerunall {} {:generator 1}
:interval-return {:interval 1} {:return 1}
:interval-return-pop {} {}
:interval-rotate {:interval 3} {:interval 3}
:interval-save {:ref 1, :interval 1} {}
:interval-savestack {:ref 1} {}
:interval-scale {:interval 1, :scalar 1} {:interval 1}
:interval-shift {:interval 1, :scalar 1} {:interval 1}
:interval-shove {:scalar 1, :interval 1} {}
:interval-stackdepth {} {:scalar 1}
:interval-store {:interval 1} {}
:interval-storestack {} {}
:interval-subset? {:interval 2} {:boolean 1}
:interval-subtract {:interval 2} {:interval 1}
:interval-swap {:interval 2} {:interval 2}
:interval-tag {:interval 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:interval-tagstack {} {:tagspace 1}
:interval-union {:interval 2} {:exec 1}
:interval-yank {:scalar 1, :interval 1} {:interval 1}
:interval-yankdup {:scalar 1, :interval 1} {:interval 1}
:intervals->code {:intervals 1} {:code 1}
:intervals->set {:intervals 1} {:set 1}
:intervals->tagspace {:intervals 1, :scalar 2} {:tagspace 1}
:intervals-againlater {:intervals 1} {:intervals 1}
:intervals-as-set {:intervals 1} {:set 1}
:intervals-build {:scalar 1} {:intervals 1}
:intervals-butlast {:intervals 1} {:intervals 1}
:intervals-byexample {:intervals 1} {:intervals 2}
:intervals-comprehension {:intervals 1} {:generator 1}
:intervals-concat {:intervals 2} {:intervals 1}
:intervals-conj {:interval 1, :intervals 1} {:intervals 1}
:intervals-conj-set {:intervals 1, :set 1} {:set 1}
:intervals-contains? {:interval 1, :intervals 1} {:boolean 1}
:intervals-cutflip {:scalar 1} {}
:intervals-cutstack {:scalar 1} {}
:intervals-cycler {:intervals 1} {:generator 1}
:intervals-cyclevector {:scalar 2} {:intervals 1}
:intervals-distinct {:intervals 1} {:intervals 1}
:intervals-do*each {:intervals 1, :exec 1} {:exec 1}
:intervals-dup {:intervals 1} {:intervals 1}
:intervals-echo {:intervals 1} {:generator 1}
:intervals-echoall {} {:generator 1}
:intervals-empty? {} {:boolean 1}
:intervals-emptyitem? {:intervals 1} {:boolean 1}
:intervals-equal? {:intervals 2} {:boolean 1}
:intervals-fillvector {:interval 1, :scalar 2} {:intervals 1}
:intervals-first {:intervals 1} {:interval 1}
:intervals-flipstack {} {}
:intervals-flush {} {}
:intervals-generalize {:intervals 1} {:vector 1}
:intervals-generalizeall {} {}
:intervals-in-set? {:intervals 1, :set 1} {:boolean 1}
:intervals-indexof {:interval 1, :intervals 1} {:scalar 1}
:intervals-intoset {:intervals 1, :set 1} {:set 1}
:intervals-items {:intervals 1} {:exec 1}
:intervals-last {:intervals 1} {:interval 1}
:intervals-later {:intervals 1} {}
:intervals-length {:intervals 1} {:scalar 1}
:intervals-liftstack {:scalar 1} {:error 1}
:intervals-new {} {:intervals 1}
:intervals-notequal? {:intervals 2} {:boolean 1}
:intervals-nth {:intervals 1, :scalar 1} {:interval 1}
:intervals-occurrencesof {:intervals 1, :interval 1} {:scalar 1}
:intervals-pop {} {}
:intervals-portion {:intervals 1, :scalar 2} {:intervals 1}
:intervals-print {:intervals 1} {:print 1}
:intervals-pt-crossover {:intervals 2, :scalar 2} {:intervals 2}
:intervals-remove {:intervals 1, :interval 1} {:intervals 1}
:intervals-replace {:intervals 1, :interval 2} {:intervals 1}
:intervals-replacefirst {:intervals 1, :interval 2} {:intervals 1}
:intervals-rerunall {} {:generator 1}
:intervals-rest {:intervals 1} {:intervals 1}
:intervals-return {:intervals 1} {:return 1}
:intervals-return-pop {} {}
:intervals-reverse {:intervals 1} {:intervals 1}
:intervals-rotate {:intervals 3} {:intervals 3}
:intervals-sampler {:intervals 1} {:generator 1}
:intervals-save {:ref 1, :intervals 1} {}
:intervals-savestack {:ref 1} {}
:intervals-set {:intervals 1, :interval 1, :scalar 1} {:intervals 1}
:intervals-shatter {:intervals 1} {}
:intervals-shove {:scalar 1, :intervals 1} {}
:intervals-stackdepth {} {:scalar 1}
:intervals-store {:intervals 1} {}
:intervals-storestack {} {}
:intervals-swap {:intervals 2} {:intervals 2}
:intervals-tag {:intervals 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:intervals-tagstack {} {:tagspace 1}
:intervals-take {:intervals 1, :scalar 1} {:intervals 1}
:intervals-vfilter {:intervals 2} {:intervals 1}
:intervals-vremove {:intervals 2} {:intervals 1}
:intervals-vsplit {:intervals 2} {:exec 1}
:intervals-yank {:scalar 1, :intervals 1} {:intervals 1}
:intervals-yankdup {:scalar 1, :intervals 1} {:intervals 1}
:log-empty? {} {:boolean 1}
:log-stackdepth {} {:scalar 1}
:print-empty? {} {:boolean 1}
:print-newline {} {:print 1}
:print-space {} {:print 1}
:print-stackdepth {} {:scalar 1}
:push-bindingcount {} {:scalar 1}
:push-bindings {} {:code 1}
:push-bindingset {} {:set 1}
:push-counter {} {:scalar 2}
:push-discardARGS {} {}
:push-instructionset {} {:set 1}
:push-nthref {:scalar 1} {:ref 1}
:push-quoterefs {} {}
:push-refcycler {} {:exec 1}
:push-storeARGS {} {}
:push-unquoterefs {} {}
:ref->code {:ref 1} {:code 1}
:ref->set {:ref 1} {:set 1}
:ref->vector {:ref 1} {:exec 1}
:ref-ARGS {} {:exec 1, :ref 1}
:ref-againlater {:ref 1} {:ref 1}
:ref-as-set {:ref 1} {:set 1}
:ref-clear {:ref 1} {}
:ref-conj-set {:ref 1, :set 1} {:set 1}
:ref-cutflip {:scalar 1} {}
:ref-cutstack {:scalar 1} {}
:ref-cyclevector {:ref 1, :scalar 2} {:exec 1}
:ref-dump {:ref 1} {:exec 1}
:ref-dup {:ref 1} {:ref 1}
:ref-echo {:ref 1} {:generator 1}
:ref-echoall {} {:generator 1}
:ref-empty? {} {:boolean 1}
:ref-equal? {:ref 2} {:boolean 1}
:ref-exchange {:ref 2} {}
:ref-fillvector {:ref 1, :scalar 2} {:exec 1}
:ref-flipstack {} {}
:ref-flush {} {}
:ref-forget {:ref 1} {}
:ref-fullquote {:ref 1} {:code 1}
:ref-in-set? {:ref 1, :set 1} {:boolean 1}
:ref-intoset {:ref 1, :set 1} {:set 1}
:ref-known? {:ref 1} {:boolean 1}
:ref-later {:ref 1} {}
:ref-liftstack {:scalar 1} {:error 1}
:ref-lookup {:ref 1} {:exec 1}
:ref-new {} {:ref 1}
:ref-notequal? {:ref 2} {:boolean 1}
:ref-peek {:ref 1} {:exec 1, :ref 1}
:ref-pop {} {}
:ref-print {:ref 1} {:print 1}
:ref-rerunall {} {:generator 1}
:ref-return {:ref 1} {:return 1}
:ref-return-pop {} {}
:ref-rotate {:ref 3} {:ref 3}
:ref-save {:ref 2} {}
:ref-savestack {:ref 1} {}
:ref-shove {:scalar 1, :ref 1} {}
:ref-stackdepth {} {:scalar 1}
:ref-store {:ref 1} {}
:ref-storestack {} {}
:ref-swap {:ref 2} {:ref 2}
:ref-tag {:ref 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:ref-tagstack {} {:tagspace 1}
:ref-yank {:scalar 1, :ref 1} {:ref 1}
:ref-yankdup {:scalar 1, :ref 1} {:ref 1}
:refs->code {:refs 1} {:code 1}
:refs->set {:refs 1} {:set 1}
:refs->tagspace {:refs 1, :scalar 2} {:tagspace 1}
:refs-againlater {:refs 1} {:refs 1}
:refs-as-set {:refs 1} {:set 1}
:refs-build {:scalar 1} {:refs 1}
:refs-butlast {:refs 1} {:refs 1}
:refs-byexample {:refs 1} {:refs 2}
:refs-comprehension {:refs 1} {:generator 1}
:refs-concat {:refs 2} {:refs 1}
:refs-conj {:ref 1, :refs 1} {:refs 1}
:refs-conj-set {:refs 1, :set 1} {:set 1}
:refs-contains? {:ref 1, :refs 1} {:boolean 1}
:refs-cutflip {:scalar 1} {}
:refs-cutstack {:scalar 1} {}
:refs-cycler {:refs 1} {:generator 1}
:refs-cyclevector {:scalar 2} {:refs 1}
:refs-distinct {:refs 1} {:refs 1}
:refs-do*each {:refs 1, :exec 1} {:exec 1}
:refs-dup {:refs 1} {:refs 1}
:refs-echo {:refs 1} {:generator 1}
:refs-echoall {} {:generator 1}
:refs-empty? {} {:boolean 1}
:refs-emptyitem? {:refs 1} {:boolean 1}
:refs-equal? {:refs 2} {:boolean 1}
:refs-fillvector {:ref 1, :scalar 2} {:refs 1}
:refs-first {:refs 1} {:ref 1}
:refs-flipstack {} {}
:refs-flush {} {}
:refs-generalize {:refs 1} {:vector 1}
:refs-generalizeall {} {}
:refs-in-set? {:refs 1, :set 1} {:boolean 1}
:refs-indexof {:ref 1, :refs 1} {:scalar 1}
:refs-intoset {:refs 1, :set 1} {:set 1}
:refs-items {:refs 1} {:exec 1}
:refs-last {:refs 1} {:ref 1}
:refs-later {:refs 1} {}
:refs-length {:refs 1} {:scalar 1}
:refs-liftstack {:scalar 1} {:error 1}
:refs-new {} {:refs 1}
:refs-notequal? {:refs 2} {:boolean 1}
:refs-nth {:refs 1, :scalar 1} {:ref 1}
:refs-occurrencesof {:refs 1, :ref 1} {:scalar 1}
:refs-pop {} {}
:refs-portion {:refs 1, :scalar 2} {:refs 1}
:refs-print {:refs 1} {:print 1}
:refs-pt-crossover {:refs 2, :scalar 2} {:refs 2}
: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 {} {:generator 1}
:refs-rest {:refs 1} {:refs 1}
:refs-return {:refs 1} {:return 1}
:refs-return-pop {} {}
:refs-reverse {:refs 1} {:refs 1}
:refs-rotate {:refs 3} {:refs 3}
:refs-sampler {:refs 1} {:generator 1}
:refs-save {:ref 1, :refs 1} {}
:refs-savestack {:ref 1} {}
:refs-set {:refs 1, :ref 1, :scalar 1} {:refs 1}
:refs-shatter {:refs 1} {}
:refs-shove {:scalar 1, :refs 1} {}
:refs-stackdepth {} {:scalar 1}
:refs-store {:refs 1} {}
:refs-storestack {} {}
:refs-swap {:refs 2} {:refs 2}
:refs-tag {:refs 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:refs-tagstack {} {:tagspace 1}
:refs-take {:refs 1, :scalar 1} {:refs 1}
:refs-vfilter {:refs 2} {:refs 1}
:refs-vremove {:refs 2} {:refs 1}
:refs-vsplit {:refs 2} {:exec 1}
:refs-yank {:scalar 1, :refs 1} {:refs 1}
:refs-yankdup {:scalar 1, :refs 1} {:refs 1}
:scalar->asciichar {:scalar 1} {:char 1}
:scalar->boolean {:scalar 1} {:boolean 1}
:scalar->char {:scalar 1} {:char 1}
:scalar->code {:scalar 1} {:code 1}
:scalar->complex {:scalar 2} {:complex 1}
:scalar->set {:scalar 1} {:set 1}
:scalar->string {:scalar 1} {:string 1}
:scalar-E {} {:scalar 1}
:scalar-abs {:scalar 1} {:scalar 1}
:scalar-add {:scalar 2} {:scalar 1, :error 1}
:scalar-againlater {:scalar 1} {:scalar 1}
:scalar-arccosine {:scalar 1} {:scalar 1, :error 1}
:scalar-arcsine {:scalar 1} {:scalar 1, :error 1}
:scalar-arctangent {:scalar 1} {:scalar 1}
:scalar-as-set {:scalar 1} {:set 1}
:scalar-bigdec? {:scalar 1} {:boolean 1}
:scalar-ceiling {:scalar 1} {:scalar 1}
:scalar-complexify {:scalar 1} {:complex 1}
:scalar-conj-set {:scalar 1, :set 1} {:set 1}
:scalar-cosine {:scalar 1} {:scalar 1}
:scalar-cutflip {:scalar 1} {}
:scalar-cutstack {:scalar 1} {}
:scalar-dec {:scalar 1} {:scalar 1}
:scalar-divide {:scalar 2} {:scalar 1, :error 1}
:scalar-dup {:scalar 1} {:scalar 1}
:scalar-echo {:scalar 1} {:generator 1}
:scalar-echoall {} {:generator 1}
:scalar-empty? {} {:boolean 1}
:scalar-equal? {:scalar 2} {:boolean 1}
:scalar-few {:scalar 1} {:scalar 1}
:scalar-flipstack {} {}
:scalar-float? {:scalar 1} {:boolean 1}
:scalar-floor {:scalar 1} {:scalar 1}
:scalar-flush {} {}
:scalar-fractional {:scalar 1} {:scalar 1}
:scalar-in-set? {:scalar 1, :set 1} {:boolean 1}
:scalar-inc {:scalar 1} {:scalar 1}
:scalar-infinite? {:scalar 1} {:boolean 1}
:scalar-integer? {:scalar 1} {:boolean 1}
:scalar-intoset {:scalar 1, :set 1} {:set 1}
:scalar-later {:scalar 1} {}
:scalar-liftstack {:scalar 1} {:error 1}
:scalar-ln {:scalar 1} {:scalar 1, :error 1}
:scalar-ln1p {:scalar 1} {:scalar 1, :error 1}
:scalar-log10 {:scalar 1} {:scalar 1, :error 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, :error 1}
:scalar-multiply {:scalar 2} {:scalar 1, :error 1}
:scalar-notequal? {:scalar 2} {:boolean 1}
:scalar-pop {} {}
:scalar-print {:scalar 1} {:print 1}
:scalar-ratio? {:scalar 1} {:boolean 1}
:scalar-reciprocal {:scalar 1} {:scalar 1}
:scalar-rerunall {} {:generator 1}
:scalar-return {:scalar 1} {:return 1}
:scalar-return-pop {} {}
:scalar-rotate {:scalar 3} {:scalar 3}
:scalar-round {:scalar 1} {:scalar 1}
:scalar-save {:ref 1, :scalar 1} {}
:scalar-savestack {:ref 1} {}
:scalar-shove {:scalar 2} {}
:scalar-sign {:scalar 1} {:scalar 1}
:scalar-sine {:scalar 1} {:scalar 1}
:scalar-some {:scalar 1} {:scalar 1}
:scalar-sqrt {:scalar 1} {:exec 1}
:scalar-stackdepth {} {:scalar 1}
:scalar-store {:scalar 1} {}
:scalar-storestack {} {}
:scalar-subtract {:scalar 2} {:scalar 1, :error 1}
:scalar-swap {:scalar 2} {:scalar 2}
:scalar-tag {:scalar 2, :tagspace 1} {:tagspace 1, :error 1}
:scalar-tagstack {} {:tagspace 1}
:scalar-tangent {:scalar 1} {:scalar 1, :error 1}
:scalar-yank {:scalar 2} {:scalar 1}
:scalar-yankdup {:scalar 2} {:scalar 1}
:scalar-π {} {:scalar 1}
:scalar<? {:scalar 2} {:boolean 1}
:scalar>? {:scalar 2} {:boolean 1}
:scalars->code {:scalars 1} {:code 1}
:scalars->set {:scalars 1} {:set 1}
:scalars->tagspace {:scalars 1, :scalar 2} {:tagspace 1}
:scalars-againlater {:scalars 1} {:scalars 1}
:scalars-as-set {:scalars 1} {:set 1}
:scalars-build {:scalar 1} {:scalars 1}
:scalars-butlast {:scalars 1} {:scalars 1}
:scalars-byexample {:scalars 1} {:scalars 2}
:scalars-comprehension {:scalars 1} {:generator 1}
:scalars-concat {:scalars 2} {:scalars 1}
:scalars-conj {:scalar 1, :scalars 1} {:scalars 1}
:scalars-conj-set {:scalars 1, :set 1} {:set 1}
:scalars-contains? {:scalar 1, :scalars 1} {:boolean 1}
:scalars-cutflip {:scalar 1} {}
:scalars-cutstack {:scalar 1} {}
:scalars-cycler {:scalars 1} {:generator 1}
:scalars-cyclevector {:scalar 2} {:scalars 1}
:scalars-distinct {:scalars 1} {:scalars 1}
:scalars-do*each {:scalars 1, :exec 1} {:exec 1}
:scalars-dup {:scalars 1} {:scalars 1}
:scalars-echo {:scalars 1} {:generator 1}
:scalars-echoall {} {:generator 1}
:scalars-empty? {} {:boolean 1}
:scalars-emptyitem? {:scalars 1} {:boolean 1}
:scalars-equal? {:scalars 2} {:boolean 1}
:scalars-fillvector {:scalar 3} {:scalars 1}
:scalars-filter {:interval 1, :scalars 1} {:scalars 1}
:scalars-first {:scalars 1} {:scalar 1}
:scalars-flipstack {} {}
:scalars-flush {} {}
:scalars-generalize {:scalars 1} {:vector 1}
:scalars-generalizeall {} {}
:scalars-in-set? {:scalars 1, :set 1} {:boolean 1}
:scalars-indexof {:scalar 1, :scalars 1} {:scalar 1}
:scalars-intoset {:scalars 1, :set 1} {:set 1}
:scalars-items {:scalars 1} {:exec 1}
:scalars-last {:scalars 1} {:scalar 1}
:scalars-later {:scalars 1} {}
:scalars-length {:scalars 1} {:scalar 1}
:scalars-liftstack {:scalar 1} {:error 1}
:scalars-new {} {:scalars 1}
:scalars-notequal? {:scalars 2} {:boolean 1}
:scalars-nth {:scalars 1, :scalar 1} {:scalar 1}
:scalars-occurrencesof {:scalars 1, :scalar 1} {:scalar 1}
:scalars-pop {} {}
:scalars-portion {:scalars 1, :scalar 2} {:scalars 1}
:scalars-print {:scalars 1} {:print 1}
:scalars-pt-crossover {:scalars 2, :scalar 2} {:scalars 2}
: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 {} {:generator 1}
:scalars-rest {:scalars 1} {:scalars 1}
:scalars-return {:scalars 1} {:return 1}
:scalars-return-pop {} {}
:scalars-reverse {:scalars 1} {:scalars 1}
:scalars-rotate {:scalars 3} {:scalars 3}
:scalars-sampler {:scalars 1} {:generator 1}
:scalars-save {:ref 1, :scalars 1} {}
:scalars-savestack {:ref 1} {}
:scalars-set {:scalars 1, :scalar 2} {:scalars 1}
:scalars-shatter {:scalars 1} {}
:scalars-shove {:scalar 1, :scalars 1} {}
:scalars-split {:interval 1, :scalars 1} {:exec 1}
:scalars-stackdepth {} {:scalar 1}
:scalars-store {:scalars 1} {}
:scalars-storestack {} {}
:scalars-swap {:scalars 2} {:scalars 2}
:scalars-tag {:scalars 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:scalars-tagstack {} {:tagspace 1}
:scalars-take {:scalars 1, :scalar 1} {:scalars 1}
:scalars-vfilter {:scalars 2} {:scalars 1}
:scalars-vremove {:scalars 2} {:scalars 1}
:scalars-vsplit {:scalars 2} {:exec 1}
:scalars-yank {:scalar 1, :scalars 1} {:scalars 1}
:scalars-yankdup {:scalar 1, :scalars 1} {:scalars 1}
:scalarsign->boolean {:scalar 1} {:boolean 1}
:scalar≤? {:scalar 2} {:boolean 1}
:scalar≥? {:scalar 2} {:boolean 1}
:set->code {:set 1} {:code 1}
:set->set {:set 1} {:set 1}
:set->tagspace {:set 1, :scalar 2} {:tagspace 1}
:set-againlater {:set 1} {:set 1}
:set-as-set {:set 1} {:set 1}
:set-comprehension {:set 1} {:generator 1}
:set-conj-set {:set 2} {:set 1}
:set-cutflip {:scalar 1} {}
:set-cutstack {:scalar 1} {}
:set-cycler {:set 1} {:generator 1}
:set-difference {:set 2} {:set 1}
:set-dup {:set 1} {:set 1}
:set-echo {:set 1} {:generator 1}
:set-echoall {} {:generator 1}
:set-empty? {} {:boolean 1}
:set-equal? {:set 2} {:boolean 1}
:set-flipstack {} {}
:set-flush {} {}
:set-in-set? {:set 2} {:boolean 1}
:set-intersection {:set 2} {:set 1}
:set-intoset {:set 2} {:set 1}
:set-later {:set 1} {}
:set-liftstack {:scalar 1} {:error 1}
:set-notequal? {:set 2} {:boolean 1}
:set-pop {} {}
:set-print {:set 1} {:print 1}
:set-rerunall {} {:generator 1}
:set-return {:set 1} {:return 1}
:set-return-pop {} {}
:set-rotate {:set 3} {:set 3}
:set-sampler {:set 1} {:generator 1}
:set-save {:ref 1, :set 1} {}
:set-savestack {:ref 1} {}
:set-shove {:scalar 1, :set 1} {}
:set-stackdepth {} {:scalar 1}
:set-store {:set 1} {}
:set-storestack {} {}
:set-subset? {:set 2} {:boolean 1}
:set-superset? {:set 2} {:boolean 1}
:set-swap {:set 2} {:set 2}
:set-tag {:set 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:set-tagstack {} {:tagspace 1}
:set-union {:set 2} {:set 1}
:set-yank {:scalar 1, :set 1} {:set 1}
:set-yankdup {:scalar 1, :set 1} {:set 1}
:snapshot->code {:snapshot 1} {:code 1}
:snapshot-againlater {:snapshot 1} {:snapshot 1}
:snapshot-begin {} {}
:snapshot-cutflip {:scalar 1} {}
:snapshot-cutstack {:scalar 1} {}
:snapshot-dup {:snapshot 1} {:snapshot 1}
:snapshot-empty? {} {:boolean 1}
:snapshot-end {:snapshot 1} {:exec 2}
:snapshot-equal? {:snapshot 2} {:boolean 1}
:snapshot-flipstack {} {}
:snapshot-flush {} {}
:snapshot-later {:snapshot 1} {}
:snapshot-liftstack {:scalar 1} {:error 1}
:snapshot-new {:exec 1} {:exec 1}
:snapshot-notequal? {:snapshot 2} {:boolean 1}
:snapshot-pop {} {}
:snapshot-rotate {:snapshot 3} {:snapshot 3}
:snapshot-save {:ref 1, :snapshot 1} {}
:snapshot-savestack {:ref 1} {}
:snapshot-shove {:scalar 1, :snapshot 1} {}
:snapshot-stackdepth {} {:scalar 1}
:snapshot-store {:snapshot 1} {}
:snapshot-storestack {} {}
:snapshot-swap {:snapshot 2} {:snapshot 2}
:snapshot-tag {:snapshot 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:snapshot-tagstack {} {:tagspace 1}
:snapshot-yank {:scalar 1, :snapshot 1} {:snapshot 1}
:snapshot-yankdup {:scalar 1, :snapshot 1} {:snapshot 1}
:string->chars {:string 1} {}
:string->code {:string 1} {:code 1}
:string->set {:string 1} {:set 1}
:string->tagspace {:string 1, :scalar 2} {:tagspace 1}
:string-againlater {:string 1} {:string 1}
:string-as-set {:string 1} {:set 1}
:string-butlast {:string 1} {:string 1}
:string-comprehension {:string 1} {:generator 1}
:string-concat {:string 2} {:string 1}
:string-conj-set {:string 1, :set 1} {:set 1}
:string-conjchar {:char 1, :string 1} {:string 1}
:string-contains? {:string 2} {:boolean 1}
:string-containschar? {:string 1, :char 1} {:boolean 1}
:string-cutflip {:scalar 1} {}
:string-cutstack {:scalar 1} {}
:string-cycler {:string 1} {:generator 1}
:string-dup {:string 1} {:string 1}
:string-echo {:string 1} {:generator 1}
:string-echoall {} {:generator 1}
:string-empty? {} {:boolean 1}
:string-emptystring? {:string 1} {:boolean 1}
:string-equal? {:string 2} {:boolean 1}
:string-first {:string 1} {:char 1}
:string-flipstack {} {}
:string-flush {} {}
:string-in-set? {:string 1, :set 1} {:boolean 1}
:string-indexofchar {:string 1, :char 1} {:scalar 1}
:string-intoset {:string 1, :set 1} {:set 1}
:string-last {:string 1} {:char 1}
:string-later {:string 1} {}
:string-length {:string 1} {:scalar 1}
:string-liftstack {:scalar 1} {:error 1}
:string-max {:string 2} {:string 1}
:string-min {:string 2} {:string 1}
:string-notequal? {:string 2} {:boolean 1}
:string-nth {:string 1, :scalar 1} {:char 1}
:string-occurrencesofchar {:string 1, :char 1} {:scalar 1}
:string-pop {} {}
:string-print {:string 1} {: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 {} {:generator 1}
:string-rest {:string 1} {:string 1}
:string-return {:string 1} {:return 1}
:string-return-pop {} {}
:string-reverse {:string 1} {:string 1}
:string-rotate {:string 3} {:string 3}
:string-sampler {:string 1} {:generator 1}
:string-save {:ref 1, :string 1} {}
:string-savestack {:ref 1} {}
:string-setchar {:string 1, :char 1, :scalar 1} {:string 1}
:string-shatter {:string 1} {}
:string-shove {:scalar 1, :string 1} {}
:string-solid? {:string 1} {:boolean 1}
:string-spacey? {:string 1} {:boolean 1}
:string-splitonspaces {:string 1} {}
:string-stackdepth {} {:scalar 1}
:string-store {:string 1} {}
:string-storestack {} {}
:string-substring {:string 1, :scalar 2} {:string 1}
:string-swap {:string 2} {:string 2}
:string-tag {:string 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:string-tagstack {} {: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 1}
:string>? {:string 2} {:boolean 1}
:strings->code {:strings 1} {:code 1}
:strings->set {:strings 1} {:set 1}
:strings->tagspace {:strings 1, :scalar 2} {:tagspace 1}
:strings-againlater {:strings 1} {:strings 1}
:strings-as-set {:strings 1} {:set 1}
:strings-build {:scalar 1} {:strings 1}
:strings-butlast {:strings 1} {:strings 1}
:strings-byexample {:strings 1} {:strings 2}
:strings-comprehension {:strings 1} {:generator 1}
:strings-concat {:strings 2} {:strings 1}
:strings-conj {:string 1, :strings 1} {:strings 1}
:strings-conj-set {:strings 1, :set 1} {:set 1}
:strings-contains? {:string 1, :strings 1} {:boolean 1}
:strings-cutflip {:scalar 1} {}
:strings-cutstack {:scalar 1} {}
:strings-cycler {:strings 1} {:generator 1}
:strings-cyclevector {:scalar 2} {:strings 1}
:strings-distinct {:strings 1} {:strings 1}
:strings-do*each {:strings 1, :exec 1} {:exec 1}
:strings-dup {:strings 1} {:strings 1}
:strings-echo {:strings 1} {:generator 1}
:strings-echoall {} {:generator 1}
:strings-empty? {} {:boolean 1}
:strings-emptyitem? {:strings 1} {:boolean 1}
:strings-equal? {:strings 2} {:boolean 1}
:strings-fillvector {:string 1, :scalar 2} {:strings 1}
:strings-first {:strings 1} {:string 1}
:strings-flipstack {} {}
:strings-flush {} {}
:strings-generalize {:strings 1} {:vector 1}
:strings-generalizeall {} {}
:strings-in-set? {:strings 1, :set 1} {:boolean 1}
:strings-indexof {:string 1, :strings 1} {:scalar 1}
:strings-intoset {:strings 1, :set 1} {:set 1}
:strings-items {:strings 1} {:exec 1}
:strings-last {:strings 1} {:string 1}
:strings-later {:strings 1} {}
:strings-length {:strings 1} {:scalar 1}
:strings-liftstack {:scalar 1} {:error 1}
:strings-new {} {:strings 1}
:strings-notequal? {:strings 2} {:boolean 1}
:strings-nth {:strings 1, :scalar 1} {:string 1}
:strings-occurrencesof {:strings 1, :string 1} {:scalar 1}
:strings-pop {} {}
:strings-portion {:strings 1, :scalar 2} {:strings 1}
:strings-print {:strings 1} {:print 1}
:strings-pt-crossover {:strings 2, :scalar 2} {:strings 2}
: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 {} {:generator 1}
:strings-rest {:strings 1} {:strings 1}
:strings-return {:strings 1} {:return 1}
:strings-return-pop {} {}
:strings-reverse {:strings 1} {:strings 1}
:strings-rotate {:strings 3} {:strings 3}
:strings-sampler {:strings 1} {:generator 1}
:strings-save {:ref 1, :strings 1} {}
:strings-savestack {:ref 1} {}
:strings-set {:strings 1, :string 1, :scalar 1} {:strings 1}
:strings-shatter {:strings 1} {}
:strings-shove {:scalar 1, :strings 1} {}
:strings-stackdepth {} {:scalar 1}
:strings-store {:strings 1} {}
:strings-storestack {} {}
:strings-swap {:strings 2} {:strings 2}
:strings-tag {:strings 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:strings-tagstack {} {:tagspace 1}
:strings-take {:strings 1, :scalar 1} {:strings 1}
:strings-vfilter {:strings 2} {:strings 1}
:strings-vremove {:strings 2} {:strings 1}
:strings-vsplit {:strings 2} {:exec 1}
:strings-yank {:scalar 1, :strings 1} {:strings 1}
:strings-yankdup {:scalar 1, :strings 1} {:strings 1}
:string≤? {:string 2} {:boolean 1}
:string≥? {:string 2} {:boolean 1}
:tagspace->code {:tagspace 1} {:code 1}
:tagspace-againlater {:tagspace 1} {:tagspace 1}
:tagspace-comprehension {:tagspace 1} {:generator 1}
:tagspace-count {:tagspace 1} {:exec 1}
:tagspace-cutflip {:scalar 1} {}
:tagspace-cutoff {:tagspace 1, :scalar 1} {:exec 1}
:tagspace-cutstack {:scalar 1} {}
:tagspace-cycler {:tagspace 1} {:generator 1}
:tagspace-dup {:tagspace 1} {:tagspace 1}
:tagspace-echo {:tagspace 1} {:generator 1}
:tagspace-echoall {} {:generator 1}
:tagspace-empty? {} {:boolean 1}
:tagspace-equal? {:tagspace 2} {:boolean 1}
:tagspace-filter {:interval 1, :tagspace 1} {:tagspace 1}
:tagspace-flipstack {} {}
:tagspace-flush {} {}
:tagspace-keys {:tagspace 1} {:exec 1}
:tagspace-keyset {:tagspace 1} {:exec 1}
:tagspace-keyvector {:tagspace 1} {:exec 1}
:tagspace-later {:tagspace 1} {}
:tagspace-liftstack {:scalar 1} {:error 1}
:tagspace-lookup {:scalar 1, :tagspace 1} {:exec 1, :tagspace 1}
:tagspace-lookupscalars {:scalars 1, :tagspace 1} {:exec 1, :tagspace 1}
:tagspace-lookupvector {:vector 1, :tagspace 1} {:exec 1, :tagspace 1}
:tagspace-max {:tagspace 1} {:exec 1}
:tagspace-merge {:tagspace 2} {:tagspace 1}
:tagspace-min {:tagspace 1} {:exec 1}
:tagspace-new {} {:tagspace 1}
:tagspace-normalize {:tagspace 1} {:tagspace 1}
:tagspace-notequal? {:tagspace 2} {:boolean 1}
:tagspace-offset {:tagspace 1, :scalar 1} {:tagspace 1}
:tagspace-pop {} {}
:tagspace-print {:tagspace 1} {:print 1}
:tagspace-remove {:interval 1, :tagspace 1} {:tagspace 1}
:tagspace-rerunall {} {:generator 1}
:tagspace-return {:tagspace 1} {:return 1}
:tagspace-return-pop {} {}
:tagspace-rotate {:tagspace 3} {:tagspace 3}
:tagspace-sampler {:tagspace 1} {:generator 1}
:tagspace-save {:ref 1, :tagspace 1} {}
:tagspace-savestack {:ref 1} {}
:tagspace-scale {:tagspace 1, :scalar 1} {:tagspace 1}
:tagspace-shove {:scalar 1, :tagspace 1} {}
:tagspace-split {:interval 1, :tagspace 1} {:exec 1}
:tagspace-stackdepth {} {:scalar 1}
:tagspace-store {:tagspace 1} {}
:tagspace-storestack {} {}
:tagspace-swap {:tagspace 2} {:tagspace 2}
:tagspace-tag {:tagspace 2, :scalar 1} {:tagspace 1, :error 1}
:tagspace-tagstack {} {:tagspace 1}
:tagspace-tidy {:tagspace 1, :scalar 2} {:tagspace 1}
:tagspace-valuefilter {:set 1, :tagspace 1} {:tagspace 1}
:tagspace-valueremove {:set 1, :tagspace 1} {:tagspace 1}
:tagspace-values {:tagspace 1} {:exec 1}
:tagspace-valueset {:tagspace 1} {:exec 1}
:tagspace-valuesplit {:set 1, :tagspace 1} {:exec 1}
:tagspace-valuevector {:tagspace 1} {:exec 1}
:tagspace-yank {:scalar 1, :tagspace 1} {:tagspace 1}
:tagspace-yankdup {:scalar 1, :tagspace 1} {:tagspace 1}
:vector->code {:vector 1} {:code 1}
:vector->set {:vector 1} {:set 1}
:vector->tagspace {:vector 1, :scalar 2} {:tagspace 1}
:vector-againlater {:vector 1} {:vector 1}
:vector-as-set {:vector 1} {:set 1}
:vector-build {:scalar 1} {:vector 1}
:vector-butlast {:vector 1} {:vector 1}
:vector-byexample {:vector 1} {:vector 2}
:vector-comprehension {:vector 1} {:generator 1}
:vector-concat {:vector 2} {:vector 1}
:vector-conj {:code 1, :vector 1} {:vector 1}
:vector-conj-set {:vector 1, :set 1} {:set 1}
:vector-contains? {:code 1, :vector 1} {:boolean 1}
:vector-cutflip {:scalar 1} {}
:vector-cutstack {:scalar 1} {}
:vector-cycler {:vector 1} {:generator 1}
:vector-cyclevector {:scalar 2} {:vector 1}
:vector-distinct {:vector 1} {:vector 1}
:vector-do*each {:vector 1, :exec 1} {:exec 1}
:vector-dup {:vector 1} {:vector 1}
:vector-echo {:vector 1} {:generator 1}
:vector-echoall {} {:generator 1}
:vector-empty? {} {:boolean 1}
:vector-emptyitem? {:vector 1} {:boolean 1}
:vector-equal? {:vector 2} {:boolean 1}
:vector-fillvector {:code 1, :scalar 2} {:vector 1}
:vector-first {:vector 1} {:code 1}
:vector-flipstack {} {}
:vector-flush {} {}
:vector-in-set? {:vector 1, :set 1} {:boolean 1}
:vector-indexof {:code 1, :vector 1} {:scalar 1}
:vector-intoset {:vector 1, :set 1} {:set 1}
:vector-items {:vector 1} {:exec 1}
:vector-last {:vector 1} {:code 1}
:vector-later {:vector 1} {}
:vector-length {:vector 1} {:scalar 1}
:vector-liftstack {:scalar 1} {:error 1}
:vector-new {} {:vector 1}
:vector-notequal? {:vector 2} {:boolean 1}
:vector-nth {:vector 1, :scalar 1} {:code 1}
:vector-occurrencesof {:vector 1, :code 1} {:scalar 1}
:vector-pop {} {}
:vector-portion {:vector 1, :scalar 2} {:vector 1}
:vector-print {:vector 1} {:print 1}
:vector-pt-crossover {:vector 2, :scalar 2} {:vector 2}
:vector-refilter {:vector 1} {:exec 1}
:vector-refilterall {} {}
: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 {} {:generator 1}
:vector-rest {:vector 1} {:vector 1}
:vector-return {:vector 1} {:return 1}
:vector-return-pop {} {}
:vector-reverse {:vector 1} {:vector 1}
:vector-rotate {:vector 3} {:vector 3}
:vector-sampler {:vector 1} {:generator 1}
:vector-save {:ref 1, :vector 1} {}
:vector-savestack {:ref 1} {}
:vector-set {:vector 1, :code 1, :scalar 1} {:vector 1}
:vector-shatter {:vector 1} {}
:vector-shove {:scalar 1, :vector 1} {}
:vector-stackdepth {} {:scalar 1}
:vector-store {:vector 1} {}
:vector-storestack {} {}
:vector-swap {:vector 2} {:vector 2}
:vector-tag {:vector 1, :tagspace 1, :scalar 1} {:tagspace 1, :error 1}
:vector-tagstack {} {:tagspace 1}
:vector-take {:vector 1, :scalar 1} {:vector 1}
:vector-vfilter {:vector 2} {:vector 1}
:vector-vremove {:vector 2} {:vector 1}
:vector-vsplit {:vector 2} {:exec 1}
:vector-yank {:scalar 1, :vector 1} {:vector 1}
:vector-yankdup {:scalar 1, :vector 1} {:vector 1}
For promiscuous routing, need to have a type hierarchy or Venn diagram