arity 0

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

types [int,int], sum = 1

types [int,chr], sum = 1

types [[[chr]]], sum = 8
(`* nary cartesian product,a1 . map) -> 2
(`' transpose,a1 . map) -> 2

types [[int]], sum = 17
(+ concat,a1 . map) -> 3
(+ concat,a1 =~ group by (also sorts)) -> 4

types chr, sum = 35
(`( to lowercase,a1 $ ) -> 2
(; save,a1 `( uncons) -> 2
(+ add auto2,a1 $ ) -> 2
(`) to uppercase,a1 $ ) -> 4
(\ char class,a1 $ ) -> 9

types [[chr]], sum = 95
(\ reverse,a1 % split (remove empties) auto2) -> 2
(+ concat,a1 \ reverse) -> 2
(>> tail,a1 . map) -> 2
(`( uncons,a1 % split (remove empties)) -> 2
(+ concat,a1 =~ group by (also sorts)) -> 2
(+ concat,a1  implicit arg ) -> 2
(, length,a1 ;;@ ) -> 2
(+ concat,a1 % split (remove empties)) -> 2
(`' transpose,a1 \ reverse) -> 2
(; save,a1 % split (remove empties) auto2) -> 2
(\ reverse,a1 ;;@ ) -> 3
(+ concat,a1 $ ) -> 3
(+ concat,a1 ! zip with) -> 4
(`* nary cartesian product,a1 . map) -> 4
(`' transpose,a1 ;;@ ) -> 5
(+ concat,a1 . map) -> 14

types [int], sum = 124
(+ add auto1,a1 , range from 1) -> 2
(>> tail,a1 _ ) -> 2
(+ sum,a1 >> tail) -> 2
(`* product,a1 ! zip with) -> 2
(`/ chunks of auto1,a1 \ reverse) -> 2
(`/ special folds,a1 . map) -> 2
(<< init,a1 \ reverse) -> 2
(`* product,a1 , range from 1) -> 2
(, length,a1 $ ) -> 2
(\ reverse,a1 `< sort) -> 2
(, length,a1 | filter) -> 2
(; save,a1 `, range from 0) -> 2
(+ sum,a1 `@ to base auto1) -> 2
(`* product,a1 _ ) -> 2
(\ reverse,a1 @ ) -> 2
(`/ chunks of auto1,a1 _ ) -> 2
(\ reverse,a1 $ ) -> 2
(\ reverse,a1 `@ to base auto1) -> 2
(`_ subsequences auto1,a1 _ ) -> 2
(; save,a1 >> tail) -> 2
(>> tail,a1 , range from 1) -> 3
(`* product,a1 $ ) -> 3
(+ sum,a1 `@ to base) -> 3
(`< sort,a1 . map) -> 3
(+ sum,a1 . map) -> 3
(`< sort,a1 _ ) -> 3
(+ sum,a1 _ ) -> 4
(\ reverse,a1 , range from 1) -> 6
(\ reverse,a1 `@ to base) -> 6

types [chr], sum = 161
(\ reverse,a1 `p int to str) -> 2
(`# hashmod,a1 $ ) -> 2
(>> tail,a1 @ ) -> 2
(`< sort,a1 @ ) -> 2
(; save,a1 : append) -> 2
(`\ special scans,a1 + add) -> 2
(`# hashmod,a1 ;@ ) -> 2
(`# hashmod,a1 @ ) -> 2
(, length,a1  implicit arg ) -> 2
(-~ strip,a1 : append) -> 2
(`/ chunks of auto1,a1 @ ) -> 2
(`' transpose,a1 ;@ ) -> 2
(\ reverse,a1 `< sort) -> 2
(% split (remove empties) auto2,a1 `D to base from data) -> 2
(`$ uniq,a1 @ ) -> 3
(\ reverse,a1 @ ) -> 3
(\ reverse,a1  implicit arg ) -> 3
(`r read int,a1 @ ) -> 3
(, length,a1 / foldr1) -> 3
(% split (remove empties) auto2,a1 ;_ ) -> 4
(`( uncons,a1 @ ) -> 4
(, length,a1 | filter) -> 4
(, length,a1 $ ) -> 4
(`< sort,a1 $ ) -> 5
(`\ special scans,a1 @ ) -> 5
(% split (remove empties) auto2,a1 @ ) -> 10

types int, sum = 217
(`, range from 0,a1 5 integer) -> 2
(^ pow auto2,a1 / divide) -> 2
(* multiply auto2,a1 , length) -> 2
(; save,a1 * multiply auto2) -> 2
(^ pow auto1,a1 @ ) -> 2
(; save,a1 ^ pow auto1) -> 2
(`, range from 0,a1 $ ) -> 2
(, range from 1,a1 3 integer) -> 2
(% modulus auto2,a1 + sum) -> 2
(, range from 1,a1 @ ) -> 2
(/ divide auto2,a1 _ ) -> 2
(`p int to str,a1 + add) -> 2
(`, range from 0,a1 256 integer) -> 2
(/ divide auto2,a1 $ ) -> 2
(`, range from 0,a1 + add auto2) -> 2
(; save,a1 % modulus) -> 2
(`p int to str,a1 $ ) -> 2
(`$ signum,a1 - subtract) -> 2
(`@ to base auto1,a1 $ ) -> 2
(- subtract auto2,a1 @ ) -> 2
(; save,a1 ^ pow) -> 2
(`p int to str,a1  implicit arg ) -> 2
(`$ signum,a1 `& bit intersection) -> 2
(; save,a1 `$ signum) -> 2
(ch chr,a1  implicit arg ) -> 2
(ch chr,a1 $ ) -> 2
(% modulus auto2,a1 $ ) -> 3
(, range from 1,a1 6 integer) -> 3
(`, range from 0,a1 10 integer) -> 4
(+ add auto2,a1 * multiply) -> 4
(^ pow auto1,a1 $ ) -> 4
(, range from 1,a1 ;$ ) -> 4
(+ add auto2,a1 @ ) -> 4
(- subtract auto2,a1 $ ) -> 4
(* multiply auto2,a1 $ ) -> 4
(+ add auto2,a1 $ ) -> 6
(, range from 1,a1 $ ) -> 19


arity 2
types ???, ???, sum = 2

types ???, [???], sum = 2

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

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

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

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

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

types [[chr]], [[chr]], sum = 4

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

types [int,int], int, sum = 4
(< take,a2 `. iterate while uniq) -> 2

types chr, fn, sum = 4

types fn, int,int,int,int, sum = 4
(`. iterate while uniq,a1 ~~~ 4-ary tuple) -> 2
(`. iterate while uniq,a2  implicit tuple) -> 2

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

types [int], chr, sum = 6

types ???, [chr], sum = 6
( implicit string concatenation,a1  implicit string concatenation) -> 3
( implicit string concatenation,a2  sorry, i don't understand this code. please report.) -> 3

types fn, int,int, sum = 6
(`. iterate while uniq,a1 ~ tuple) -> 2
(`. iterate while uniq,a2  implicit tuple) -> 2

types fn, int,int,int, sum = 6
(`. iterate while uniq,a1 ~~ 3-ary tuple) -> 3
(`. iterate while uniq,a2  implicit tuple) -> 3

types [int,int,int], fn, sum = 8

types [[int]], int, sum = 8

types [int,int], fn, sum = 10

types [[[chr]]], fn, sum = 12
( implicit map,a2 + concat) -> 2

types [int], [int], sum = 14
(`% split list (keep empties),a1 `@ to base) -> 2
(`% split list (keep empties),a2 `D to base from data) -> 2

types chr, chr, sum = 20
(- subtract,a1 $ ) -> 2

types [chr], [int], sum = 24
(* join,a2 . map) -> 2
(* join,a2 < take) -> 2
(* join,a1 ;@ ) -> 3

types chr, int, sum = 34
(- subtract,a2  implicit arg ) -> 2
(^ replicate,a1 $ ) -> 2
(- subtract,a1 @ ) -> 2

types [[int]], fn, sum = 42
(. map,a2 * join) -> 2
( implicit map,a1 `/ chunks of auto1) -> 2
(. map,a1 `/ chunks of auto1) -> 2
(. map,a1 `* nary cartesian product) -> 2
(. map,a1 `_ subsequences auto1) -> 2
(. map,a2 / foldr1) -> 2
(/ foldr1,a1 `= chunk by) -> 2
(. map,a1 ;;$ ) -> 2
(. map,a2 `* product) -> 3

types [chr], chr, sum = 52
(: append,a1 = subscript (wrapped)) -> 2
(: append,a2 = subscript (wrapped)) -> 2
(: append,a1 `( uncons) -> 2
(? index,a2 $ ) -> 2
(: append,a1 $ ) -> 2
(: append,a2  implicit arg ) -> 2
(: append,a2 $ ) -> 3

types [[chr]], [chr], sum = 56
(* join,a2 % split (remove empties)) -> 2
(: append,a1 `: list of 2 lists) -> 2
(* join,a1 "+" string) -> 2
(: append,a2 _ ) -> 2
(* join,a2 `' transpose) -> 3
(: append,a2 $ ) -> 3
(* join,a2 . map) -> 3
(: append,a1 @ ) -> 3
(: append,a1 : append) -> 3
(: append,a2 : append) -> 3
(* join,a1 " " string) -> 4

types [[chr]], int, sum = 60
(= subscript (wrapped),a1 , length) -> 2
( implicit tuple,a1 ? if/else) -> 2
(~ tuple,a2 0 integer) -> 2
(~ tuple,a1 : append) -> 2
(=~ subscript nowrap,a1 2 integer) -> 2
(< take,a2 `. iterate while uniq) -> 2
(= subscript (wrapped),a2 $ ) -> 2
( implicit tuple,a2  implicit arg ) -> 3
(= subscript (wrapped),a1 $ ) -> 3
(= subscript (wrapped),a2 % split (remove empties) auto2) -> 3

types fn, int, sum = 62
(== equal?,a2 _ ) -> 2
(`. iterate while uniq,a2 + add) -> 2
( implicit string concatenation,a1 $ ) -> 2
(`. iterate while uniq,a1 $ ) -> 2
( implicit map with implicit range,a2 / foldr1) -> 2
( implicit map with implicit range,a2 . map) -> 2
( implicit map with implicit range,a1 9 integer) -> 2
(== equal?,a1 $ ) -> 3
( implicit map with implicit range,a2 : append) -> 3
( implicit map with implicit range,a1 $ ) -> 7

types [int], int, sum = 80
(`@ from base,a2 \ reverse) -> 2
(< take,a1 ;$ ) -> 2
(< take,a2 > drop) -> 2
(+ add,a1 $ ) -> 2
(: append,a1 1 integer) -> 2
(> drop,a1 2 integer) -> 2
(< take,a2 | filter) -> 2
(: append,a1 $ ) -> 2
(+ add,a2 `, range from 0) -> 3
(< take,a1 $ ) -> 3

types [[chr]], fn, sum = 112
( implicit map,a2 / foldr1) -> 2
( implicit map,a2 = subscript (wrapped)) -> 2
(. map,a1 `= chunk by) -> 2
(/ foldr1,a1 % split (remove empties) auto2) -> 2
(. map,a2 ? if/else) -> 2
(. map,a1 % split (remove empties) auto2) -> 2
(. map,a1 `' transpose) -> 2
(. map,a2 / foldr1) -> 2
(. map,a1 ;;@ ) -> 2
(. map,a1 \ reverse) -> 2
(/ foldr1,a1 $ ) -> 2
(! zip with,a1 `% split list (keep empties)) -> 2
(. map,a1 `/ chunks of auto1) -> 2
(| filter,a1 ;;@ ) -> 3
(/ foldr1,a2 $ ) -> 3
( implicit map,a1 `' transpose) -> 4
(. map,a2 : append) -> 4
(/ foldr1,a2  implicit arg ) -> 4

types [chr], int, sum = 150
(^ replicate,a2 `p int to str) -> 2
(< take,a2 $ ) -> 2
(> drop,a1 $ ) -> 2
(= subscript (wrapped),a2 @ ) -> 2
(= subscript (wrapped),a1 $ ) -> 2
(: append,a1 ^ replicate) -> 2
( implicit string concatenation,a2 $ ) -> 2
(: append,a2 ^ pow auto2) -> 2
(: append,a2  implicit arg ) -> 2
(^ replicate,a1 , length) -> 2
(^ replicate,a2 ;@ ) -> 2
(= subscript (wrapped),a2 `< sort) -> 2
(`< take also drop,a1 $ ) -> 2
(`< take also drop,a2 _ ) -> 2
(^ replicate,a2 " " string) -> 3
(: append,a2 $ ) -> 3
( implicit string concatenation,a1  implicit string concatenation) -> 7
(^ replicate,a1 $ ) -> 7

types [chr], fn, sum = 164
(| filter,a2  implicit arg ) -> 2
(=~ group by (also sorts),a1 @ ) -> 2
(. map,a2 ^ replicate) -> 2
(| filter,a2 $ ) -> 2
(. map,a2 `) to uppercase) -> 2
(`= chunk by,a1 @ ) -> 2
(. map,a1 `\ special scans) -> 2
(| filter,a1  implicit arg ) -> 2
(. map,a2 - subtract) -> 2
(`\ special scans,a1 \ reverse) -> 2
(`. iterate while uniq,a2 : append) -> 2
(`= chunk by,a2 $ ) -> 2
(/ foldr1,a1  implicit arg ) -> 2
(. map,a1 $ ) -> 2
(. map,a2 ? if/else) -> 3
(. map,a2 : append) -> 4
(`. iterate while uniq,a1 @ ) -> 4
(/ foldr1,a2 $ ) -> 5
(| filter,a1 @ ) -> 5
(/ foldr1,a1 @ ) -> 5
(| filter,a2 \ char class) -> 6
(/ foldr1,a2 @ ) -> 7
(/ foldr1,a1 $ ) -> 7
(/ foldr1,a2  implicit arg ) -> 7
(. map,a1 @ ) -> 9

types [chr], [chr], sum = 222
( implicit string concatenation,a2 + concat) -> 2
(: append,a1 \ reverse) -> 2
( implicit string concatenation,a2 ")" string) -> 2
(: append,a1 < take) -> 2
( implicit string concatenation,a2 "\n" string) -> 2
(: append,a1 `< take also drop) -> 2
( implicit tuple,a1 : append) -> 2
( implicit string concatenation,a2 " " string) -> 2
(% split (remove empties),a1 * join) -> 2
(: append,a2 " " string) -> 2
(`: list of 2 lists,a2 @ ) -> 2
( implicit string concatenation,a2 ; save) -> 2
(: append,a1 @ ) -> 2
( implicit string concatenation,a2 ;~ save fn) -> 2
(: append,a1 ^ replicate) -> 2
( implicit tuple,a2  implicit arg ) -> 2
(% split (remove empties),a1 $ ) -> 2
(`: list of 2 lists,a1 ; save) -> 2
(- diff,a1 $ ) -> 3
(: append,a1 _ ) -> 3
( implicit string concatenation,a2 ^ replicate) -> 3
(: append,a2 ^ replicate) -> 3
(: append,a2 "\n" string) -> 3
(% split (remove empties),a2 "\n" string) -> 3
( implicit string concatenation,a2 * join) -> 3
(: append,a2 $ ) -> 4
(: append,a2  implicit arg ) -> 4
(: append,a2 : append) -> 5
( implicit string concatenation,a2 $ ) -> 5
(% split (remove empties),a1 @ ) -> 5
( implicit string concatenation,a2 @ ) -> 6
(: append,a1 : append) -> 9
( implicit string concatenation,a1  implicit string concatenation) -> 33

types [int], fn, sum = 224
(! zip with,a1 _ ) -> 2
(| filter,a1 . map) -> 2
(| filter,a1 + add auto1) -> 2
( implicit map,a2 ch chr) -> 2
(. map,a2 = subscript (wrapped)) -> 2
( implicit map,a1 \ reverse) -> 2
(. map,a1 `D to base from data) -> 2
(. map,a2 - subtract) -> 2
(. map,a2 ch chr) -> 2
( implicit map,a1 << init) -> 2
( implicit foldl1,a1 : append) -> 2
(! zip with,a1 : append) -> 2
( implicit foldl1,a2 % modulus) -> 2
(. map,a1 _ ) -> 2
( implicit map,a1 ; save) -> 2
(/ foldr1,a1 \ reverse) -> 2
( implicit map,a2 : append) -> 2
(. map,a2 ^ pow) -> 2
(. map,a2 / foldr1) -> 2
(. map,a1 `@ to base) -> 2
(`= chunk by,a1 _ ) -> 2
(. map,a2 ? if/else) -> 2
(`= chunk by,a2 $ ) -> 2
( implicit map,a2 + concat) -> 2
(. map,a1 $ ) -> 2
(=~ group by (also sorts),a1 `< sort) -> 2
(=~ group by (also sorts),a2 , length) -> 2
(/ foldr1,a2 == equal?) -> 2
(=~ group by (also sorts),a1 | filter) -> 2
(| filter,a2 - subtract) -> 3
(. map,a2 & justify) -> 3
(/ foldr1,a1 $ ) -> 3
(/ foldr1,a1 | filter) -> 4
(. map,a1 , range from 1 auto1) -> 4
(/ foldr1,a1 _ ) -> 4
( implicit map,a1 `, range from 0) -> 4
(. map,a1 `, range from 0) -> 4
(. map,a2 . map) -> 4
(| filter,a2 % modulus) -> 5
(. map,a2 ^ replicate) -> 5
(| filter,a1 , range from 1) -> 5
(/ foldr1,a2  implicit arg ) -> 6
(/ foldr1,a2 @ ) -> 6
(. map,a1 , range from 1) -> 12

types int, int, sum = 498
(`^ bit xor,a2  implicit arg ) -> 2
(* multiply,a1 + add auto2) -> 2
(`& bit intersection,a2 _ ) -> 2
( implicit tuple,a1 + add) -> 2
(`^ bit xor,a1 ;$ ) -> 2
(`^ bit xor,a2 @ ) -> 2
(^ pow,a1 5 integer) -> 2
(% modulus,a2 $ ) -> 2
(- subtract,a1 - subtract) -> 2
(- subtract,a2 % modulus) -> 2
(^ pow,a1 $ ) -> 2
(^ pow,a1 ; save) -> 2
([ min,a1 $ ) -> 2
(/ divide,a2  implicit arg ) -> 2
(+ add,a1 ;$ ) -> 2
(* multiply,a1 $ ) -> 2
(* multiply,a2 ;@ ) -> 2
(^ pow,a2 @ ) -> 2
(+ add,a1 , length) -> 2
(^ pow,a2  implicit arg ) -> 2
(`@ to base,a2 @ ) -> 2
(`@ to base,a1 6 integer) -> 2
(* multiply,a1 ; save) -> 2
(/ divide,a1 , length) -> 2
(* multiply,a1 _ ) -> 2
(+ add,a1 * multiply) -> 2
(^ pow,a2 10 integer) -> 2
(+ add,a1 + add) -> 2
(`/ divmod,a2 60 integer) -> 2
(- subtract,a2 * multiply) -> 2
(% modulus,a2 _ ) -> 2
(/ divide,a2 10 integer) -> 2
(+ add,a2 / divide) -> 2
(* multiply,a1 , length) -> 2
(* multiply,a2 5 integer) -> 2
(* multiply,a1 % modulus) -> 2
(* multiply,a2 _ ) -> 2
(- subtract,a2 + sum) -> 2
(- subtract,a2  implicit arg ) -> 2
(* multiply,a2 @ ) -> 2
(/ divide,a2 * multiply) -> 2
(+ add,a1 / divide) -> 2
(/ divide,a1 $ ) -> 2
(- subtract,a1 / divide auto2) -> 2
(+ add,a1 % modulus) -> 2
(* multiply,a2 ^ pow auto1) -> 2
(% modulus,a1 + add auto2) -> 2
(% modulus,a2 3 integer) -> 2
(^ pow,a2 ;$ ) -> 2
(- subtract,a2 ^ pow auto1 auto2) -> 2
(`& bit intersection,a1 ; save) -> 2
(/ divide,a2 9 integer) -> 3
(% modulus,a2 4 integer) -> 3
(`/ divmod,a1 `/ divmod) -> 3
(^ pow,a2 ^ pow) -> 3
(/ divide,a1 @ ) -> 3
(^ pow,a1 @ ) -> 3
(- subtract,a1 3 integer) -> 3
(`/ divmod,a1 $ ) -> 3
(% modulus,a1 ^ pow) -> 3
(+ add,a2 @ ) -> 3
(- subtract,a2 @ ) -> 3
(- subtract,a2 * multiply auto2) -> 3
(- subtract,a1 * multiply) -> 3
(* multiply,a1 @ ) -> 3
(+ add,a1  implicit arg ) -> 3
(+ add,a1 - subtract) -> 3
(* multiply,a1  implicit arg ) -> 3
(/ divide,a1 * multiply) -> 3
(/ divide,a2 $ ) -> 4
(/ divide,a1 ^ pow auto1) -> 4
(* multiply,a1 / divide) -> 4
(% modulus,a1 * multiply) -> 4
(`@ to base,a1 $ ) -> 4
(`@ to base,a2 $ ) -> 4
(`@ to base,a2  implicit arg ) -> 4
(- subtract,a1 _ ) -> 4
(- subtract,a2 $ ) -> 4
(* multiply,a1 ^ pow) -> 4
(% modulus,a1 + add) -> 4
(% modulus,a1 @ ) -> 5
(- subtract,a1 $ ) -> 5
(^ pow,a2 $ ) -> 5
(+ add,a1 @ ) -> 5
(- subtract,a2 , length) -> 6
(* multiply,a1 * multiply) -> 6
(^ pow,a1 2 integer) -> 6
(% modulus,a2  implicit arg ) -> 7
(`@ to base,a1 2 integer) -> 7
(- subtract,a1 @ ) -> 7
(+ add,a2  implicit arg ) -> 10
(* multiply,a2  implicit arg ) -> 10
(+ add,a2 $ ) -> 12
(* multiply,a2 $ ) -> 14


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

types fn, int, int,int, sum = 3

types [[[chr]]], [[chr]],int, fn, sum = 3

types [int,chr], fn, fn, sum = 3

types [chr], [chr],[chr], fn, sum = 3

types chr, chr,[chr], fn, sum = 3

types [chr], [chr], fn, sum = 3

types [[chr]], [[chr]],int, fn, sum = 3

types [chr],[chr], [int], fn, sum = 3

types [[chr]], fn, int, sum = 6
(? if/else,a2 : append) -> 2
(? if/else,a3 : append) -> 2

types [[chr]],int, fn, int, sum = 6
(? if/else,a2 ~ tuple) -> 2
(? if/else,a3  implicit tuple) -> 2

types [[chr]], [chr], int, sum = 9
(& justify,a2 -1 integer) -> 2
(& justify,a3 . map) -> 2
(& justify,a1 " " string) -> 3

types chr, chr, fn, sum = 9
(? if/else,a2 $ ) -> 2
(? if/else,a1 $ ) -> 2
(? if/else,a3  implicit arg ) -> 2

types [chr], int, int, sum = 12
(& justify,a1 "0" string) -> 2
(& justify,a1 " " string) -> 2
(& justify,a2 2 integer) -> 3
(& justify,a3 $ ) -> 3

types [[chr]], fn, fn, sum = 12

types [chr], fn, fn, sum = 15
(! zip with,a1 @ ) -> 2

types [chr], fn, int, sum = 18
(? if/else,a1 - subtract) -> 2

types [int], fn, fn, sum = 18
(=\ scanl,a2 1 integer) -> 2
(=\ scanl,a1 , range from 1) -> 2

types chr, fn, int, sum = 18
(? if/else,a3 ? if/else) -> 2
(? if/else,a1 % modulus auto2) -> 2
(? if/else,a3  implicit arg ) -> 3

types [chr], [chr], int, sum = 21
(& justify,a1 " " string) -> 6

types int, int, int, sum = 24
( implicit tuple,a2 $ ) -> 2
( implicit tuple,a3 + add) -> 2

types fn, int, int, sum = 36
(? if/else,a2 + add) -> 2
(? if/else,a3  implicit arg ) -> 2
(? if/else,a1 $ ) -> 2
(? if/else,a3 + add) -> 2


arity 4
types int, int, int, int, sum = 16
( implicit tuple,a4 % modulus) -> 2
(~~~ 4-ary tuple,a2 0 integer) -> 2
(~~~ 4-ary tuple,a3 1 integer) -> 2
(~~~ 4-ary tuple,a4 1 integer) -> 2
( implicit tuple,a1 ; save) -> 2
( implicit tuple,a2 `^ bit xor) -> 2
( implicit tuple,a3 ; save) -> 2
(~~~ 4-ary tuple,a1 0 integer) -> 2