arity 0
types , sum = 1689
49 integer -> 2
'a' char -> 2
"NO" string -> 2
"YES" string -> 2
33 integer -> 2
`, range from 0 auto1 -> 2
- zipop: sub -> 2
"#" string -> 2
* foldop: mult -> 2
256 integer -> 2
~ ...tition -> 2
7 integer -> 2
~ par...... -> 2
13 integer -> 2
'A' char -> 2
> foldop: max by fn -> 2
"1." string -> 2
a isAlpha -> 2
`$ signum auto1 -> 2
n isAlphaNum -> 2
"" string -> 2
"!" string -> 2
u isUpper -> 2
5 hashmod arg -> 2
35 integer -> 2
100 to base from data arg -> 2
'@' char -> 2
"]" string -> 2
"x" string -> 2
-26 to base from data arg -> 2
"*" string -> 2
29 integer -> 2
2 hashmod arg -> 2
-4 integer -> 2
"[" string -> 2
+ foldop: add -> 3
11 integer -> 3
2 to base from data arg -> 3
")" string -> 3
50 integer -> 3
"/" string -> 3
~ default -> 3
16 integer -> 3
, zipop: make tuple -> 3
32 integer -> 3
"." string -> 3
12 integer -> 3
31 integer -> 3
-1 integer -> 3
: foldop: cons -> 3
] foldop: max -> 3
~ nosort -> 3
20 integer -> 4
"+" string -> 4
;;$  -> 4
; foldop: rev cons -> 4
"0" string -> 4
8 integer -> 4
40 integer -> 4
60 integer -> 4
":" string -> 5
= zipop: subscript -> 6
: zipop: cons -> 6
"," string -> 6
~ zipop: by -> 7
^ pow auto1 auto2 -> 7
~ not -> 8
9 integer -> 9
 sorry, i don't understand this code. please report. -> 9
6 integer -> 11
, range from 1 auto1 -> 11
4 integer -> 12
5 integer -> 13
1 integer -> 13
"\n" string -> 14
10 integer -> 20
;_  -> 21
`D to base from data -> 21
3 integer -> 21
0 integer -> 23
;@  -> 26
;;@  -> 26
" " string -> 30
;$  -> 33
2 integer -> 35
_  -> 98
 implicit arg  -> 148
~ auto -> 192
@  -> 212
$  -> 344


arity 1
types [[int],[int]], sum = 1

types [[chr,int]], sum = 1

types [int,chr], sum = 2

types [chr,int], sum = 2

types [int,int,int,int], sum = 2

types int,int,int,int, sum = 2
`. iterate while uniq -> 2

types int,int,int, sum = 3
`. iterate while uniq -> 3

types int,int, sum = 3
`. iterate while uniq -> 2

types [int,int,int], sum = 4

types [int,int], sum = 6
. map -> 2

types [[[chr]]], sum = 14
+ concat -> 2
`' transpose -> 2
`* nary cartesian product -> 2
. map -> 2
 implicit map -> 3

types chr, sum = 37
, range from 1 -> 2
- subtract auto2 -> 2
+ add auto2 -> 2
`( to lowercase -> 3
o ord -> 3
; save -> 4
`) to uppercase -> 6
\ char class -> 10

types [[int]], sum = 38
/ foldr1 -> 2
| filter -> 2
 implicit map -> 3
>> tail -> 3
`* nary cartesian product -> 3
+ concat -> 8
. map -> 13

types [[chr]], sum = 155
`) swapped uncons -> 2
/ foldr -> 2
`/ chunks of auto1 -> 2
=~ group by (also sorts) -> 2
=\ scanl1 -> 2
`< sort -> 3
<< init -> 3
; save -> 3
, length -> 5
>> tail -> 5
`( uncons -> 5
`* nary cartesian product -> 6
| filter -> 6
! zip with -> 7
/ foldr1 -> 11
`' transpose -> 11
 implicit map -> 12
\ reverse -> 13
. map -> 15
+ concat -> 33

types [int], sum = 242
``p permutations -> 2
=\ scanl1 -> 2
`\ n chunks auto1 -> 2
`( uncons -> 2
 implicit foldl1 -> 2
+ add auto1 -> 3
`_ subsequences auto1 -> 3
=\ scanl -> 3
<< init -> 3
`/ special folds -> 3
`\ special scans -> 3
`= chunk by -> 4
: append auto2 -> 4
`/ chunks of auto1 -> 6
=~ group by (also sorts) -> 7
, length -> 7
; save -> 8
>> tail -> 9
`< sort -> 10
! zip with -> 11
`* product -> 12
| filter -> 15
 implicit map -> 16
/ foldr1 -> 19
+ sum -> 20
\ reverse -> 24
. map -> 34

types int, sum = 248
hex to/from hex -> 2
@  -> 2
$  -> 2
: append auto2 -> 2
? if/else -> 2
`# hashmod -> 2
^ pow auto2 -> 3
* multiply auto1 -> 3
- subtract auto1 -> 3
`. iterate while uniq -> 4
 implicit string concatenation -> 4
`$ signum -> 5
`@ to base auto1 -> 5
ch chr -> 5
== equal? -> 6
/ divide auto2 -> 8
% modulus auto2 -> 8
* multiply auto2 -> 11
`p int to str -> 11
^ pow auto1 -> 13
 implicit map with implicit range -> 13
- subtract auto2 -> 14
`, range from 0 -> 22
+ add auto2 -> 22
; save -> 23
, range from 1 -> 47

types [chr], sum = 248
`% step auto1 -> 2
or or -> 2
== equal? -> 2
hex to/from hex -> 2
/ foldr -> 2
`) swapped uncons -> 3
=~ group by (also sorts) -> 3
-~ strip -> 3
^ replicate auto1 -> 3
`= chunk by -> 4
<< init -> 4
`. iterate while uniq -> 5
`' transpose -> 5
`$ uniq -> 5
`/ chunks of auto1 -> 6
>> tail -> 7
`# hashmod -> 7
! zip with -> 8
`< sort -> 9
`r read int -> 9
`( uncons -> 9
; save -> 10
`\ special scans -> 11
| filter -> 12
\ reverse -> 18
. map -> 20
, length -> 21
/ foldr1 -> 21
% split (remove empties) auto2 -> 24


arity 2
types [chr],[chr], [int], sum = 1

types ???, ???, sum = 1

types ???,???, [chr], sum = 1

types [[[chr]]], [[chr]],int, sum = 1

types int, int,int, sum = 1

types [int,int,int], int, sum = 1

types [[chr]], [[chr]],int, sum = 1

types chr, chr,[chr], sum = 1

types [chr], [chr],[chr], sum = 1

types ???, [???], sum = 1

types [int,int], int, sum = 2
< take -> 2

types [[[chr]]], int, sum = 2

types [[chr]],int, int, sum = 2
? if/else -> 2

types [[chr]], [[chr]], sum = 2
: append -> 2

types [int], chr, sum = 3
+ add -> 3

types ???, [chr], sum = 3
 implicit string concatenation -> 3

types [[int]], int, sum = 4
= subscript (wrapped) -> 2

types [int], [int], sum = 7
`% split list (keep empties) -> 2
: append -> 4

types [chr], [int], sum = 12
: append -> 2
 implicit string concatenation -> 2
* join -> 8

types chr, chr, sum = 13
: append -> 2
/ divide -> 2
- subtract -> 3
? if/else -> 3

types chr, int, sum = 23
/ divide -> 2
% modulus -> 2
- subtract -> 3
+ add -> 3
^ replicate -> 4
? if/else -> 6

types [chr], chr, sum = 26
 implicit string concatenation -> 2
? index -> 5
: append -> 15

types [[chr]], [chr], sum = 28
? index -> 3
: append -> 11
* join -> 13

types [[chr]], int, sum = 32
=~ subscript nowrap -> 2
^ replicate -> 2
? if/else -> 2
~ tuple -> 4
 implicit tuple -> 4
< take -> 5
= subscript (wrapped) -> 12

types [int], int, sum = 40
`_ subsequences -> 2
^ replicate -> 2
= subscript (wrapped) -> 3
`/ chunks of -> 3
+ add -> 4
> drop -> 4
`@ from base -> 4
: append -> 6
< take -> 10

types [chr], int, sum = 81
`< take also drop -> 4
< take -> 5
? if/else -> 6
> drop -> 6
= subscript (wrapped) -> 9
 implicit string concatenation -> 10
: append -> 14
^ replicate -> 22

types [chr], [chr], sum = 112
 implicit tuple -> 2
~ tuple -> 3
`: list of 2 lists -> 4
`% split list (keep empties) -> 5
- diff -> 6
% split (remove empties) -> 14
: append -> 35
 implicit string concatenation -> 42

types int, int, sum = 261
[ min -> 2
`% moddiv -> 2
;$  -> 2
!= abs diff -> 2
: append -> 3
 implicit tuple -> 3
~ tuple -> 4
`^ bit xor -> 4
`& bit intersection -> 5
`/ divmod -> 8
? if/else -> 12
`@ to base -> 20
/ divide -> 22
^ pow -> 23
% modulus -> 27
- subtract -> 37
+ add -> 39
* multiply -> 45


arity 3
types [chr], [chr], [chr], sum = 1

types [[chr]], [chr], int, sum = 3
& justify -> 3

types [chr], int, int, sum = 4
& justify -> 4

types [chr], [chr], int, sum = 7
& justify -> 6

types int, int, int, sum = 8
~~ 3-ary tuple -> 3
 implicit tuple -> 4


arity 4
types int, int, int, int, sum = 4
~~~ 4-ary tuple -> 2
 implicit tuple -> 2