**** New globals: {T:{b:b, i:i, i1:i1, i2:i2, i4:i4, i8:i8, n:r8, qb:b?, qi:i?, qi1:i1?, qi2:i2?, qi4:i4?, qi8:i8?, qn:r8?, qr4:r4?, qr8:r8?, qu1:u1?, qu2:u2?, qu4:u4?, qu8:u8?, r4:r4, r8:r8, s:s, u1:u1, u2:u2, u4:u4, u8:u8}*}
**** Add globals: {R:{A:i4}, U:{A:i4}*}
**** Add globals: {bs:b*, i1s:i1*, i2s:i2*, i4s:i4*, i8s:i8*, ias:i*, r4s:r4*, r8s:r8*, u1s:u1*, u2s:u2*, u4s:u4*, u8s:u8*}
**** Add globals: {qbs:b?*, qi1s:i1?*, qi2s:i2?*, qi4s:i4?*, qi8s:i8?*, qias:i?*, qr4s:r4?*, qr8s:r8?*, qu1s:u1?*, qu2s:u2?*, qu4s:u4?*, qu8s:u8?*}
**** Add globals: {vs:v*}

> Sum(r8s)
Sum(r8s) : r8
Binder : Sum(r8s)
###
> Min(r8s)
Min(r8s) : r8
Binder : Min(r8s)
###
> Max(r8s)
Max(r8s) : r8
Binder : Max(r8s)
###
> MinMax(r8s)
MinMax(r8s) : {Max:r8, Min:r8}
Binder : MinMax(r8s)
###
> SumC(r8s)
SumC(r8s) : {Count:i8, Sum:r8}
Binder : SumC(r8s)
###
> MinC(r8s)
MinC(r8s) : {Count:i8, Min:r8}
Binder : MinC(r8s)
###
> MaxC(r8s)
MaxC(r8s) : {Count:i8, Max:r8}
Binder : MaxC(r8s)
###
> MinMaxC(r8s)
MinMaxC(r8s) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(r8s)
###
> Sum(r4s)
Sum(r4s) : r8
Binder : Sum(r4s)
###
> Min(r4s)
Min(r4s) : r4
Binder : Min(r4s)
###
> Max(r4s)
Max(r4s) : r4
Binder : Max(r4s)
###
> MinMax(r4s)
MinMax(r4s) : {Max:r4, Min:r4}
Binder : MinMax(r4s)
###
> SumC(r4s)
SumC(r4s) : {Count:i8, Sum:r8}
Binder : SumC(r4s)
###
> MinC(r4s)
MinC(r4s) : {Count:i8, Min:r4}
Binder : MinC(r4s)
###
> MaxC(r4s)
MaxC(r4s) : {Count:i8, Max:r4}
Binder : MaxC(r4s)
###
> MinMaxC(r4s)
MinMaxC(r4s) : {Count:i8, Max:r4, Min:r4}
Binder : MinMaxC(r4s)
###
> Sum(i8s)
Sum(i8s) : i8
Binder : Sum(i8s)
###
> Min(i8s)
Min(i8s) : i8
Binder : Min(i8s)
###
> Max(i8s)
Max(i8s) : i8
Binder : Max(i8s)
###
> MinMax(i8s)
MinMax(i8s) : {Max:i8, Min:i8}
Binder : MinMax(i8s)
###
> SumC(i8s)
SumC(i8s) : {Count:i8, Sum:i8}
Binder : SumC(i8s)
###
> MinC(i8s)
MinC(i8s) : {Count:i8, Min:i8}
Binder : MinC(i8s)
###
> MaxC(i8s)
MaxC(i8s) : {Count:i8, Max:i8}
Binder : MaxC(i8s)
###
> MinMaxC(i8s)
MinMaxC(i8s) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(i8s)
###
> Sum(i4s)
Sum(i4s) : i8
Binder : Sum(i4s)
###
> Min(i4s)
Min(i4s) : i4
Binder : Min(i4s)
###
> Max(i4s)
Max(i4s) : i4
Binder : Max(i4s)
###
> MinMax(i4s)
MinMax(i4s) : {Max:i4, Min:i4}
Binder : MinMax(i4s)
###
> SumC(i4s)
SumC(i4s) : {Count:i8, Sum:i8}
Binder : SumC(i4s)
###
> MinC(i4s)
MinC(i4s) : {Count:i8, Min:i4}
Binder : MinC(i4s)
###
> MaxC(i4s)
MaxC(i4s) : {Count:i8, Max:i4}
Binder : MaxC(i4s)
###
> MinMaxC(i4s)
MinMaxC(i4s) : {Count:i8, Max:i4, Min:i4}
Binder : MinMaxC(i4s)
###
> Sum(i2s)
Sum(i2s) : i8
Binder : Sum(i2s)
###
> Min(i2s)
Min(i2s) : i2
Binder : Min(i2s)
###
> Max(i2s)
Max(i2s) : i2
Binder : Max(i2s)
###
> MinMax(i2s)
MinMax(i2s) : {Max:i2, Min:i2}
Binder : MinMax(i2s)
###
> SumC(i2s)
SumC(i2s) : {Count:i8, Sum:i8}
Binder : SumC(i2s)
###
> MinC(i2s)
MinC(i2s) : {Count:i8, Min:i2}
Binder : MinC(i2s)
###
> MaxC(i2s)
MaxC(i2s) : {Count:i8, Max:i2}
Binder : MaxC(i2s)
###
> MinMaxC(i2s)
MinMaxC(i2s) : {Count:i8, Max:i2, Min:i2}
Binder : MinMaxC(i2s)
###
> Sum(i1s)
Sum(i1s) : i8
Binder : Sum(i1s)
###
> Min(i1s)
Min(i1s) : i1
Binder : Min(i1s)
###
> Max(i1s)
Max(i1s) : i1
Binder : Max(i1s)
###
> MinMax(i1s)
MinMax(i1s) : {Max:i1, Min:i1}
Binder : MinMax(i1s)
###
> SumC(i1s)
SumC(i1s) : {Count:i8, Sum:i8}
Binder : SumC(i1s)
###
> MinC(i1s)
MinC(i1s) : {Count:i8, Min:i1}
Binder : MinC(i1s)
###
> MaxC(i1s)
MaxC(i1s) : {Count:i8, Max:i1}
Binder : MaxC(i1s)
###
> MinMaxC(i1s)
MinMaxC(i1s) : {Count:i8, Max:i1, Min:i1}
Binder : MinMaxC(i1s)
###
> Sum(u8s)
Sum(u8s) : u8
Binder : Sum(u8s)
###
> Min(u8s)
Min(u8s) : u8
Binder : Min(u8s)
###
> Max(u8s)
Max(u8s) : u8
Binder : Max(u8s)
###
> MinMax(u8s)
MinMax(u8s) : {Max:u8, Min:u8}
Binder : MinMax(u8s)
###
> SumC(u8s)
SumC(u8s) : {Count:i8, Sum:u8}
Binder : SumC(u8s)
###
> MinC(u8s)
MinC(u8s) : {Count:i8, Min:u8}
Binder : MinC(u8s)
###
> MaxC(u8s)
MaxC(u8s) : {Count:i8, Max:u8}
Binder : MaxC(u8s)
###
> MinMaxC(u8s)
MinMaxC(u8s) : {Count:i8, Max:u8, Min:u8}
Binder : MinMaxC(u8s)
###
> Sum(u4s)
Sum(u4s) : i8
Binder : Sum(u4s)
###
> Min(u4s)
Min(u4s) : u4
Binder : Min(u4s)
###
> Max(u4s)
Max(u4s) : u4
Binder : Max(u4s)
###
> MinMax(u4s)
MinMax(u4s) : {Max:u4, Min:u4}
Binder : MinMax(u4s)
###
> SumC(u4s)
SumC(u4s) : {Count:i8, Sum:i8}
Binder : SumC(u4s)
###
> MinC(u4s)
MinC(u4s) : {Count:i8, Min:u4}
Binder : MinC(u4s)
###
> MaxC(u4s)
MaxC(u4s) : {Count:i8, Max:u4}
Binder : MaxC(u4s)
###
> MinMaxC(u4s)
MinMaxC(u4s) : {Count:i8, Max:u4, Min:u4}
Binder : MinMaxC(u4s)
###
> Sum(u2s)
Sum(u2s) : i8
Binder : Sum(u2s)
###
> Min(u2s)
Min(u2s) : u2
Binder : Min(u2s)
###
> Max(u2s)
Max(u2s) : u2
Binder : Max(u2s)
###
> MinMax(u2s)
MinMax(u2s) : {Max:u2, Min:u2}
Binder : MinMax(u2s)
###
> SumC(u2s)
SumC(u2s) : {Count:i8, Sum:i8}
Binder : SumC(u2s)
###
> MinC(u2s)
MinC(u2s) : {Count:i8, Min:u2}
Binder : MinC(u2s)
###
> MaxC(u2s)
MaxC(u2s) : {Count:i8, Max:u2}
Binder : MaxC(u2s)
###
> MinMaxC(u2s)
MinMaxC(u2s) : {Count:i8, Max:u2, Min:u2}
Binder : MinMaxC(u2s)
###
> Sum(u1s)
Sum(u1s) : i8
Binder : Sum(u1s)
###
> Min(u1s)
Min(u1s) : u1
Binder : Min(u1s)
###
> Max(u1s)
Max(u1s) : u1
Binder : Max(u1s)
###
> MinMax(u1s)
MinMax(u1s) : {Max:u1, Min:u1}
Binder : MinMax(u1s)
###
> SumC(u1s)
SumC(u1s) : {Count:i8, Sum:i8}
Binder : SumC(u1s)
###
> MinC(u1s)
MinC(u1s) : {Count:i8, Min:u1}
Binder : MinC(u1s)
###
> MaxC(u1s)
MaxC(u1s) : {Count:i8, Max:u1}
Binder : MaxC(u1s)
###
> MinMaxC(u1s)
MinMaxC(u1s) : {Count:i8, Max:u1, Min:u1}
Binder : MinMaxC(u1s)
###
> Sum(ias)
Sum(ias) : i
Binder : Sum(ias)
###
> Min(ias)
Min(ias) : i
Binder : Min(ias)
###
> Max(ias)
Max(ias) : i
Binder : Max(ias)
###
> MinMax(ias)
MinMax(ias) : {Max:i, Min:i}
Binder : MinMax(ias)
###
> SumC(ias)
SumC(ias) : {Count:i8, Sum:i}
Binder : SumC(ias)
###
> MinC(ias)
MinC(ias) : {Count:i8, Min:i}
Binder : MinC(ias)
###
> MaxC(ias)
MaxC(ias) : {Count:i8, Max:i}
Binder : MaxC(ias)
###
> MinMaxC(ias)
MinMaxC(ias) : {Count:i8, Max:i, Min:i}
Binder : MinMaxC(ias)
###
> Sum(bs)
Sum(bs) : i8
Binder : Sum(bs)
###
> Min(bs)
Min(bs) : b
Binder : Min(bs)
###
> Max(bs)
Max(bs) : b
Binder : Max(bs)
###
> MinMax(bs)
MinMax(bs) : {Max:b, Min:b}
Binder : MinMax(bs)
###
> SumC(bs)
SumC(bs) : {Count:i8, Sum:i8}
Binder : SumC(bs)
###
> MinC(bs)
MinC(bs) : {Count:i8, Min:b}
Binder : MinC(bs)
###
> MaxC(bs)
MaxC(bs) : {Count:i8, Max:b}
Binder : MaxC(bs)
###
> MinMaxC(bs)
MinMaxC(bs) : {Count:i8, Max:b, Min:b}
Binder : MinMaxC(bs)
###
> Sum(qr8s)
Sum(qr8s) : r8
Binder : Sum(qr8s)
###
> Min(qr8s)
Min(qr8s) : r8
Binder : Min(qr8s)
###
> Max(qr8s)
Max(qr8s) : r8
Binder : Max(qr8s)
###
> MinMax(qr8s)
MinMax(qr8s) : {Max:r8, Min:r8}
Binder : MinMax(qr8s)
###
> SumC(qr8s)
SumC(qr8s) : {Count:i8, Sum:r8}
Binder : SumC(qr8s)
###
> MinC(qr8s)
MinC(qr8s) : {Count:i8, Min:r8}
Binder : MinC(qr8s)
###
> MaxC(qr8s)
MaxC(qr8s) : {Count:i8, Max:r8}
Binder : MaxC(qr8s)
###
> MinMaxC(qr8s)
MinMaxC(qr8s) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(qr8s)
###
> Sum(qr4s)
Sum(qr4s) : r8
Binder : Sum(qr4s)
###
> Min(qr4s)
Min(qr4s) : r4
Binder : Min(qr4s)
###
> Max(qr4s)
Max(qr4s) : r4
Binder : Max(qr4s)
###
> MinMax(qr4s)
MinMax(qr4s) : {Max:r4, Min:r4}
Binder : MinMax(qr4s)
###
> SumC(qr4s)
SumC(qr4s) : {Count:i8, Sum:r8}
Binder : SumC(qr4s)
###
> MinC(qr4s)
MinC(qr4s) : {Count:i8, Min:r4}
Binder : MinC(qr4s)
###
> MaxC(qr4s)
MaxC(qr4s) : {Count:i8, Max:r4}
Binder : MaxC(qr4s)
###
> MinMaxC(qr4s)
MinMaxC(qr4s) : {Count:i8, Max:r4, Min:r4}
Binder : MinMaxC(qr4s)
###
> Sum(qi8s)
Sum(qi8s) : i8
Binder : Sum(qi8s)
###
> Min(qi8s)
Min(qi8s) : i8
Binder : Min(qi8s)
###
> Max(qi8s)
Max(qi8s) : i8
Binder : Max(qi8s)
###
> MinMax(qi8s)
MinMax(qi8s) : {Max:i8, Min:i8}
Binder : MinMax(qi8s)
###
> SumC(qi8s)
SumC(qi8s) : {Count:i8, Sum:i8}
Binder : SumC(qi8s)
###
> MinC(qi8s)
MinC(qi8s) : {Count:i8, Min:i8}
Binder : MinC(qi8s)
###
> MaxC(qi8s)
MaxC(qi8s) : {Count:i8, Max:i8}
Binder : MaxC(qi8s)
###
> MinMaxC(qi8s)
MinMaxC(qi8s) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(qi8s)
###
> Sum(qi4s)
Sum(qi4s) : i8
Binder : Sum(qi4s)
###
> Min(qi4s)
Min(qi4s) : i4
Binder : Min(qi4s)
###
> Max(qi4s)
Max(qi4s) : i4
Binder : Max(qi4s)
###
> MinMax(qi4s)
MinMax(qi4s) : {Max:i4, Min:i4}
Binder : MinMax(qi4s)
###
> SumC(qi4s)
SumC(qi4s) : {Count:i8, Sum:i8}
Binder : SumC(qi4s)
###
> MinC(qi4s)
MinC(qi4s) : {Count:i8, Min:i4}
Binder : MinC(qi4s)
###
> MaxC(qi4s)
MaxC(qi4s) : {Count:i8, Max:i4}
Binder : MaxC(qi4s)
###
> MinMaxC(qi4s)
MinMaxC(qi4s) : {Count:i8, Max:i4, Min:i4}
Binder : MinMaxC(qi4s)
###
> Sum(qi2s)
Sum(qi2s) : i8
Binder : Sum(qi2s)
###
> Min(qi2s)
Min(qi2s) : i2
Binder : Min(qi2s)
###
> Max(qi2s)
Max(qi2s) : i2
Binder : Max(qi2s)
###
> MinMax(qi2s)
MinMax(qi2s) : {Max:i2, Min:i2}
Binder : MinMax(qi2s)
###
> SumC(qi2s)
SumC(qi2s) : {Count:i8, Sum:i8}
Binder : SumC(qi2s)
###
> MinC(qi2s)
MinC(qi2s) : {Count:i8, Min:i2}
Binder : MinC(qi2s)
###
> MaxC(qi2s)
MaxC(qi2s) : {Count:i8, Max:i2}
Binder : MaxC(qi2s)
###
> MinMaxC(qi2s)
MinMaxC(qi2s) : {Count:i8, Max:i2, Min:i2}
Binder : MinMaxC(qi2s)
###
> Sum(qi1s)
Sum(qi1s) : i8
Binder : Sum(qi1s)
###
> Min(qi1s)
Min(qi1s) : i1
Binder : Min(qi1s)
###
> Max(qi1s)
Max(qi1s) : i1
Binder : Max(qi1s)
###
> MinMax(qi1s)
MinMax(qi1s) : {Max:i1, Min:i1}
Binder : MinMax(qi1s)
###
> SumC(qi1s)
SumC(qi1s) : {Count:i8, Sum:i8}
Binder : SumC(qi1s)
###
> MinC(qi1s)
MinC(qi1s) : {Count:i8, Min:i1}
Binder : MinC(qi1s)
###
> MaxC(qi1s)
MaxC(qi1s) : {Count:i8, Max:i1}
Binder : MaxC(qi1s)
###
> MinMaxC(qi1s)
MinMaxC(qi1s) : {Count:i8, Max:i1, Min:i1}
Binder : MinMaxC(qi1s)
###
> Sum(qu8s)
Sum(qu8s) : u8
Binder : Sum(qu8s)
###
> Min(qu8s)
Min(qu8s) : u8
Binder : Min(qu8s)
###
> Max(qu8s)
Max(qu8s) : u8
Binder : Max(qu8s)
###
> MinMax(qu8s)
MinMax(qu8s) : {Max:u8, Min:u8}
Binder : MinMax(qu8s)
###
> SumC(qu8s)
SumC(qu8s) : {Count:i8, Sum:u8}
Binder : SumC(qu8s)
###
> MinC(qu8s)
MinC(qu8s) : {Count:i8, Min:u8}
Binder : MinC(qu8s)
###
> MaxC(qu8s)
MaxC(qu8s) : {Count:i8, Max:u8}
Binder : MaxC(qu8s)
###
> MinMaxC(qu8s)
MinMaxC(qu8s) : {Count:i8, Max:u8, Min:u8}
Binder : MinMaxC(qu8s)
###
> Sum(qu4s)
Sum(qu4s) : i8
Binder : Sum(qu4s)
###
> Min(qu4s)
Min(qu4s) : u4
Binder : Min(qu4s)
###
> Max(qu4s)
Max(qu4s) : u4
Binder : Max(qu4s)
###
> MinMax(qu4s)
MinMax(qu4s) : {Max:u4, Min:u4}
Binder : MinMax(qu4s)
###
> SumC(qu4s)
SumC(qu4s) : {Count:i8, Sum:i8}
Binder : SumC(qu4s)
###
> MinC(qu4s)
MinC(qu4s) : {Count:i8, Min:u4}
Binder : MinC(qu4s)
###
> MaxC(qu4s)
MaxC(qu4s) : {Count:i8, Max:u4}
Binder : MaxC(qu4s)
###
> MinMaxC(qu4s)
MinMaxC(qu4s) : {Count:i8, Max:u4, Min:u4}
Binder : MinMaxC(qu4s)
###
> Sum(qu2s)
Sum(qu2s) : i8
Binder : Sum(qu2s)
###
> Min(qu2s)
Min(qu2s) : u2
Binder : Min(qu2s)
###
> Max(qu2s)
Max(qu2s) : u2
Binder : Max(qu2s)
###
> MinMax(qu2s)
MinMax(qu2s) : {Max:u2, Min:u2}
Binder : MinMax(qu2s)
###
> SumC(qu2s)
SumC(qu2s) : {Count:i8, Sum:i8}
Binder : SumC(qu2s)
###
> MinC(qu2s)
MinC(qu2s) : {Count:i8, Min:u2}
Binder : MinC(qu2s)
###
> MaxC(qu2s)
MaxC(qu2s) : {Count:i8, Max:u2}
Binder : MaxC(qu2s)
###
> MinMaxC(qu2s)
MinMaxC(qu2s) : {Count:i8, Max:u2, Min:u2}
Binder : MinMaxC(qu2s)
###
> Sum(qu1s)
Sum(qu1s) : i8
Binder : Sum(qu1s)
###
> Min(qu1s)
Min(qu1s) : u1
Binder : Min(qu1s)
###
> Max(qu1s)
Max(qu1s) : u1
Binder : Max(qu1s)
###
> MinMax(qu1s)
MinMax(qu1s) : {Max:u1, Min:u1}
Binder : MinMax(qu1s)
###
> SumC(qu1s)
SumC(qu1s) : {Count:i8, Sum:i8}
Binder : SumC(qu1s)
###
> MinC(qu1s)
MinC(qu1s) : {Count:i8, Min:u1}
Binder : MinC(qu1s)
###
> MaxC(qu1s)
MaxC(qu1s) : {Count:i8, Max:u1}
Binder : MaxC(qu1s)
###
> MinMaxC(qu1s)
MinMaxC(qu1s) : {Count:i8, Max:u1, Min:u1}
Binder : MinMaxC(qu1s)
###
> Sum(qias)
Sum(qias) : i
Binder : Sum(qias)
###
> Min(qias)
Min(qias) : i
Binder : Min(qias)
###
> Max(qias)
Max(qias) : i
Binder : Max(qias)
###
> MinMax(qias)
MinMax(qias) : {Max:i, Min:i}
Binder : MinMax(qias)
###
> SumC(qias)
SumC(qias) : {Count:i8, Sum:i}
Binder : SumC(qias)
###
> MinC(qias)
MinC(qias) : {Count:i8, Min:i}
Binder : MinC(qias)
###
> MaxC(qias)
MaxC(qias) : {Count:i8, Max:i}
Binder : MaxC(qias)
###
> MinMaxC(qias)
MinMaxC(qias) : {Count:i8, Max:i, Min:i}
Binder : MinMaxC(qias)
###
> Sum(qbs)
Sum(qbs) : i8
Binder : Sum(qbs)
###
> Min(qbs)
Min(qbs) : b
Binder : Min(qbs)
###
> Max(qbs)
Max(qbs) : b
Binder : Max(qbs)
###
> MinMax(qbs)
MinMax(qbs) : {Max:b, Min:b}
Binder : MinMax(qbs)
###
> SumC(qbs)
SumC(qbs) : {Count:i8, Sum:i8}
Binder : SumC(qbs)
###
> MinC(qbs)
MinC(qbs) : {Count:i8, Min:b}
Binder : MinC(qbs)
###
> MaxC(qbs)
MaxC(qbs) : {Count:i8, Max:b}
Binder : MaxC(qbs)
###
> MinMaxC(qbs)
MinMaxC(qbs) : {Count:i8, Max:b, Min:b}
Binder : MinMaxC(qbs)
###
> Sum(T, n)
Sum(T, n) : r8
Binder : Sum(*1: T, *1.n)
###
> Sum(T.n)
Sum(T.n) : r8
Binder : Sum(ForEach(*1: T, *1.n))
Reducer: Sum(*1: T, *1.n)
###
> Min(T, n)
Min(T, n) : r8
Binder : Min(*1: T, *1.n)
###
> Min(T.n)
Min(T.n) : r8
Binder : Min(ForEach(*1: T, *1.n))
Reducer: Min(*1: T, *1.n)
###
> Max(T, n)
Max(T, n) : r8
Binder : Max(*1: T, *1.n)
###
> Max(T.n)
Max(T.n) : r8
Binder : Max(ForEach(*1: T, *1.n))
Reducer: Max(*1: T, *1.n)
###
> MinMax(T, n)
MinMax(T, n) : {Max:r8, Min:r8}
Binder : MinMax(*1: T, *1.n)
###
> MinMax(T.n)
MinMax(T.n) : {Max:r8, Min:r8}
Binder : MinMax(ForEach(*1: T, *1.n))
Reducer: MinMax(*1: T, *1.n)
###
> SumC(T, n)
SumC(T, n) : {Count:i8, Sum:r8}
Binder : SumC(*1: T, *1.n)
###
> SumC(T.n)
SumC(T.n) : {Count:i8, Sum:r8}
Binder : SumC(ForEach(*1: T, *1.n))
Reducer: SumC(*1: T, *1.n)
###
> MinC(T, n)
MinC(T, n) : {Count:i8, Min:r8}
Binder : MinC(*1: T, *1.n)
###
> MinC(T.n)
MinC(T.n) : {Count:i8, Min:r8}
Binder : MinC(ForEach(*1: T, *1.n))
Reducer: MinC(*1: T, *1.n)
###
> MaxC(T, n)
MaxC(T, n) : {Count:i8, Max:r8}
Binder : MaxC(*1: T, *1.n)
###
> MaxC(T.n)
MaxC(T.n) : {Count:i8, Max:r8}
Binder : MaxC(ForEach(*1: T, *1.n))
Reducer: MaxC(*1: T, *1.n)
###
> MinMaxC(T, n)
MinMaxC(T, n) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(*1: T, *1.n)
###
> MinMaxC(T.n)
MinMaxC(T.n) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(ForEach(*1: T, *1.n))
Reducer: MinMaxC(*1: T, *1.n)
###
> Sum(T, qn)
Sum(T, qn) : r8
Binder : Sum(*1: T, *1.qn)
###
> Sum(T.qn)
Sum(T.qn) : r8
Binder : Sum(ForEach(*1: T, *1.qn))
Reducer: Sum(*1: T, *1.qn)
###
> Min(T, qn)
Min(T, qn) : r8
Binder : Min(*1: T, *1.qn)
###
> Min(T.qn)
Min(T.qn) : r8
Binder : Min(ForEach(*1: T, *1.qn))
Reducer: Min(*1: T, *1.qn)
###
> Max(T, qn)
Max(T, qn) : r8
Binder : Max(*1: T, *1.qn)
###
> Max(T.qn)
Max(T.qn) : r8
Binder : Max(ForEach(*1: T, *1.qn))
Reducer: Max(*1: T, *1.qn)
###
> MinMax(T, qn)
MinMax(T, qn) : {Max:r8, Min:r8}
Binder : MinMax(*1: T, *1.qn)
###
> MinMax(T.qn)
MinMax(T.qn) : {Max:r8, Min:r8}
Binder : MinMax(ForEach(*1: T, *1.qn))
Reducer: MinMax(*1: T, *1.qn)
###
> SumC(T, qn)
SumC(T, qn) : {Count:i8, Sum:r8}
Binder : SumC(*1: T, *1.qn)
###
> SumC(T.qn)
SumC(T.qn) : {Count:i8, Sum:r8}
Binder : SumC(ForEach(*1: T, *1.qn))
Reducer: SumC(*1: T, *1.qn)
###
> MinC(T, qn)
MinC(T, qn) : {Count:i8, Min:r8}
Binder : MinC(*1: T, *1.qn)
###
> MinC(T.qn)
MinC(T.qn) : {Count:i8, Min:r8}
Binder : MinC(ForEach(*1: T, *1.qn))
Reducer: MinC(*1: T, *1.qn)
###
> MaxC(T, qn)
MaxC(T, qn) : {Count:i8, Max:r8}
Binder : MaxC(*1: T, *1.qn)
###
> MaxC(T.qn)
MaxC(T.qn) : {Count:i8, Max:r8}
Binder : MaxC(ForEach(*1: T, *1.qn))
Reducer: MaxC(*1: T, *1.qn)
###
> MinMaxC(T, qn)
MinMaxC(T, qn) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(*1: T, *1.qn)
###
> MinMaxC(T.qn)
MinMaxC(T.qn) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(ForEach(*1: T, *1.qn))
Reducer: MinMaxC(*1: T, *1.qn)
###
> Sum(T, i2) // Needs type promotion.
Sum(T, i2) : i8
Binder : Sum(*1: T, Num<i8>(*1.i2))
###
> Sum(T.i2) // Needs type promotion.
Sum(T.i2) : i8
Binder : Sum(ForEach(*1: T, *1.i2))
Reducer: Sum(*1: T, Num<i8>(*1.i2))
###
> Min(T, i2)
Min(T, i2) : i2
Binder : Min(*1: T, *1.i2)
###
> Min(T.i2)
Min(T.i2) : i2
Binder : Min(ForEach(*1: T, *1.i2))
Reducer: Min(*1: T, *1.i2)
###
> Max(T, i2)
Max(T, i2) : i2
Binder : Max(*1: T, *1.i2)
###
> Max(T.i2)
Max(T.i2) : i2
Binder : Max(ForEach(*1: T, *1.i2))
Reducer: Max(*1: T, *1.i2)
###
> MinMax(T, i2)
MinMax(T, i2) : {Max:i2, Min:i2}
Binder : MinMax(*1: T, *1.i2)
###
> MinMax(T.i2)
MinMax(T.i2) : {Max:i2, Min:i2}
Binder : MinMax(ForEach(*1: T, *1.i2))
Reducer: MinMax(*1: T, *1.i2)
###
> SumC(T, i2) // Needs type promotion.
SumC(T, i2) : {Count:i8, Sum:i8}
Binder : SumC(*1: T, Num<i8>(*1.i2))
###
> SumC(T.i2) // Needs type promotion.
SumC(T.i2) : {Count:i8, Sum:i8}
Binder : SumC(ForEach(*1: T, *1.i2))
Reducer: SumC(*1: T, Num<i8>(*1.i2))
###
> MinC(T, i2)
MinC(T, i2) : {Count:i8, Min:i2}
Binder : MinC(*1: T, *1.i2)
###
> MinC(T.i2)
MinC(T.i2) : {Count:i8, Min:i2}
Binder : MinC(ForEach(*1: T, *1.i2))
Reducer: MinC(*1: T, *1.i2)
###
> MaxC(T, i2)
MaxC(T, i2) : {Count:i8, Max:i2}
Binder : MaxC(*1: T, *1.i2)
###
> MaxC(T.i2)
MaxC(T.i2) : {Count:i8, Max:i2}
Binder : MaxC(ForEach(*1: T, *1.i2))
Reducer: MaxC(*1: T, *1.i2)
###
> MinMaxC(T, i2)
MinMaxC(T, i2) : {Count:i8, Max:i2, Min:i2}
Binder : MinMaxC(*1: T, *1.i2)
###
> MinMaxC(T.i2)
MinMaxC(T.i2) : {Count:i8, Max:i2, Min:i2}
Binder : MinMaxC(ForEach(*1: T, *1.i2))
Reducer: MinMaxC(*1: T, *1.i2)
###
> Sum(T, u1) // Needs type promotion.
Sum(T, u1) : i8
Binder : Sum(*1: T, Num<i8>(*1.u1))
###
> Sum(T.u1) // Needs type promotion.
Sum(T.u1) : i8
Binder : Sum(ForEach(*1: T, *1.u1))
Reducer: Sum(*1: T, Num<i8>(*1.u1))
###
> Sum(T, i4 * i2)
Sum(T, i4 * i2) : i8
Binder : Sum(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> Sum(T.i4 * T.i2)
Sum(T.i4 * T.i2) : i8
Binder : Sum(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: Sum(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> Min(T, i4 * i2)
Min(T, i4 * i2) : i8
Binder : Min(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> Min(T.i4 * T.i2)
Min(T.i4 * T.i2) : i8
Binder : Min(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: Min(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> Max(T, i4 * i2)
Max(T, i4 * i2) : i8
Binder : Max(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> Max(T.i4 * T.i2)
Max(T.i4 * T.i2) : i8
Binder : Max(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: Max(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MinMax(T, i4 * i2)
MinMax(T, i4 * i2) : {Max:i8, Min:i8}
Binder : MinMax(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MinMax(T.i4 * T.i2)
MinMax(T.i4 * T.i2) : {Max:i8, Min:i8}
Binder : MinMax(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MinMax(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> SumC(T, i4 * i2)
SumC(T, i4 * i2) : {Count:i8, Sum:i8}
Binder : SumC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> SumC(T.i4 * T.i2)
SumC(T.i4 * T.i2) : {Count:i8, Sum:i8}
Binder : SumC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: SumC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MinC(T, i4 * i2)
MinC(T, i4 * i2) : {Count:i8, Min:i8}
Binder : MinC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MinC(T.i4 * T.i2)
MinC(T.i4 * T.i2) : {Count:i8, Min:i8}
Binder : MinC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MinC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MaxC(T, i4 * i2)
MaxC(T, i4 * i2) : {Count:i8, Max:i8}
Binder : MaxC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MaxC(T.i4 * T.i2)
MaxC(T.i4 * T.i2) : {Count:i8, Max:i8}
Binder : MaxC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MaxC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MinMaxC(T, i4 * i2)
MinMaxC(T, i4 * i2) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> MinMaxC(T.i4 * T.i2)
MinMaxC(T.i4 * T.i2) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: T, *2.i2), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MinMaxC(*1: T, Mul(Num<i8>(*1.i4), Num<i8>(*1.i2)))
###
> Sum(T, qi4 * i2)
Sum(T, qi4 * i2) : i8
Binder : Sum(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> Sum(T.qi4 * T.i2)
Sum(T.qi4 * T.i2) : i8
Binder : Sum(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: Sum(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> Min(T, qi4 * i2)
Min(T, qi4 * i2) : i8
Binder : Min(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> Min(T.qi4 * T.i2)
Min(T.qi4 * T.i2) : i8
Binder : Min(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: Min(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> Max(T, qi4 * i2)
Max(T, qi4 * i2) : i8
Binder : Max(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> Max(T.qi4 * T.i2)
Max(T.qi4 * T.i2) : i8
Binder : Max(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: Max(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MinMax(T, qi4 * i2)
MinMax(T, qi4 * i2) : {Max:i8, Min:i8}
Binder : MinMax(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MinMax(T.qi4 * T.i2)
MinMax(T.qi4 * T.i2) : {Max:i8, Min:i8}
Binder : MinMax(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MinMax(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> SumC(T, qi4 * i2)
SumC(T, qi4 * i2) : {Count:i8, Sum:i8}
Binder : SumC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> SumC(T.qi4 * T.i2)
SumC(T.qi4 * T.i2) : {Count:i8, Sum:i8}
Binder : SumC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: SumC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MinC(T, qi4 * i2)
MinC(T, qi4 * i2) : {Count:i8, Min:i8}
Binder : MinC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MinC(T.qi4 * T.i2)
MinC(T.qi4 * T.i2) : {Count:i8, Min:i8}
Binder : MinC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MinC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MaxC(T, qi4 * i2)
MaxC(T, qi4 * i2) : {Count:i8, Max:i8}
Binder : MaxC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MaxC(T.qi4 * T.i2)
MaxC(T.qi4 * T.i2) : {Count:i8, Max:i8}
Binder : MaxC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MaxC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MinMaxC(T, qi4 * i2)
MinMaxC(T, qi4 * i2) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> MinMaxC(T.qi4 * T.i2)
MinMaxC(T.qi4 * T.i2) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: T, *2.i2), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MinMaxC(*1: T, Guard(?2: *1.qi4, Mul(Num<i8>(?2), Num<i8>(*1.i2))))
###
> Sum(T, U, i4 * A)
Sum(T, U, i4 * A) : i8
Binder : Sum(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: Sum(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> Sum(T.i4 * U.A)
Sum(T.i4 * U.A) : i8
Binder : Sum(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: Sum(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> Min(T, U, i4 * A)
Min(T, U, i4 * A) : i8
Binder : Min(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: Min(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> Min(T.i4 * U.A)
Min(T.i4 * U.A) : i8
Binder : Min(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: Min(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> Max(T, U, i4 * A)
Max(T, U, i4 * A) : i8
Binder : Max(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: Max(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> Max(T.i4 * U.A)
Max(T.i4 * U.A) : i8
Binder : Max(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: Max(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MinMax(T, U, i4 * A)
MinMax(T, U, i4 * A) : {Max:i8, Min:i8}
Binder : MinMax(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: MinMax(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MinMax(T.i4 * U.A)
MinMax(T.i4 * U.A) : {Max:i8, Min:i8}
Binder : MinMax(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MinMax(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> SumC(T, U, i4 * A)
SumC(T, U, i4 * A) : {Count:i8, Sum:i8}
Binder : SumC(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: SumC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> SumC(T.i4 * U.A)
SumC(T.i4 * U.A) : {Count:i8, Sum:i8}
Binder : SumC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: SumC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MinC(T, U, i4 * A)
MinC(T, U, i4 * A) : {Count:i8, Min:i8}
Binder : MinC(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: MinC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MinC(T.i4 * U.A)
MinC(T.i4 * U.A) : {Count:i8, Min:i8}
Binder : MinC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MinC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MaxC(T, U, i4 * A)
MaxC(T, U, i4 * A) : {Count:i8, Max:i8}
Binder : MaxC(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: MaxC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MaxC(T.i4 * U.A)
MaxC(T.i4 * U.A) : {Count:i8, Max:i8}
Binder : MaxC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MaxC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MinMaxC(T, U, i4 * A)
MinMaxC(T, U, i4 * A) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A)))
Reducer: MinMaxC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> MinMaxC(T.i4 * U.A)
MinMaxC(T.i4 * U.A) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(ForEach(*3: ForEach(*1: T, *1.i4), *4: ForEach(*2: U, *2.A), Mul(Num<i8>(*3), Num<i8>(*4))))
Reducer: MinMaxC(ForEach(*1: T, *2: U, Mul(Num<i8>(*1.i4), Num<i8>(*2.A))))
###
> Sum(T, U, qi4 * A)
Sum(T, U, qi4 * A) : i8
Binder : Sum(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: Sum(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> Sum(T.qi4 * U.A)
Sum(T.qi4 * U.A) : i8
Binder : Sum(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: Sum(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> Min(T, U, qi4 * A)
Min(T, U, qi4 * A) : i8
Binder : Min(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: Min(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> Min(T.qi4 * U.A)
Min(T.qi4 * U.A) : i8
Binder : Min(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: Min(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> Max(T, U, qi4 * A)
Max(T, U, qi4 * A) : i8
Binder : Max(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: Max(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> Max(T.qi4 * U.A)
Max(T.qi4 * U.A) : i8
Binder : Max(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: Max(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MinMax(T, U, qi4 * A)
MinMax(T, U, qi4 * A) : {Max:i8, Min:i8}
Binder : MinMax(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: MinMax(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MinMax(T.qi4 * U.A)
MinMax(T.qi4 * U.A) : {Max:i8, Min:i8}
Binder : MinMax(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MinMax(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> SumC(T, U, qi4 * A)
SumC(T, U, qi4 * A) : {Count:i8, Sum:i8}
Binder : SumC(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: SumC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> SumC(T.qi4 * U.A)
SumC(T.qi4 * U.A) : {Count:i8, Sum:i8}
Binder : SumC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: SumC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MinC(T, U, qi4 * A)
MinC(T, U, qi4 * A) : {Count:i8, Min:i8}
Binder : MinC(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: MinC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MinC(T.qi4 * U.A)
MinC(T.qi4 * U.A) : {Count:i8, Min:i8}
Binder : MinC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MinC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MaxC(T, U, qi4 * A)
MaxC(T, U, qi4 * A) : {Count:i8, Max:i8}
Binder : MaxC(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: MaxC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MaxC(T.qi4 * U.A)
MaxC(T.qi4 * U.A) : {Count:i8, Max:i8}
Binder : MaxC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MaxC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MinMaxC(T, U, qi4 * A)
MinMaxC(T, U, qi4 * A) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A))))
Reducer: MinMaxC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> MinMaxC(T.qi4 * U.A)
MinMaxC(T.qi4 * U.A) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(ForEach(*3: ForEach(*1: T, *1.qi4), *4: ForEach(*2: U, *2.A), Guard(?5: *3, Mul(Num<i8>(?5), Num<i8>(*4)))))
Reducer: MinMaxC(ForEach(*1: T, *2: U, Guard(?3: *1.qi4, Mul(Num<i8>(?3), Num<i8>(*2.A)))))
###
> Sum(x: T.i4 * 2, 9 max #x)
Sum(x : T.i4 * 2, 9 max #x) : i8
Binder : Sum(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: Sum(*2: T, Max(9, #1))
###
> Min(x: T.i4 * 2, 9 max #x)
Min(x : T.i4 * 2, 9 max #x) : i8
Binder : Min(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: Min(*2: T, Max(9, #1))
###
> Max(x: T.i4 * 2, 9 max #x)
Max(x : T.i4 * 2, 9 max #x) : i8
Binder : Max(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: Max(*2: T, Max(9, #1))
###
> MinMax(x: T.i4 * 2, 9 max #x)
MinMax(x : T.i4 * 2, 9 max #x) : {Max:i8, Min:i8}
Binder : MinMax(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: MinMax(*2: T, Max(9, #1))
###
> SumC(x: T.i4 * 2, 9 max #x)
SumC(x : T.i4 * 2, 9 max #x) : {Count:i8, Sum:i8}
Binder : SumC(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: SumC(*2: T, Max(9, #1))
###
> MinC(x: T.i4 * 2, 9 max #x)
MinC(x : T.i4 * 2, 9 max #x) : {Count:i8, Min:i8}
Binder : MinC(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: MinC(*2: T, Max(9, #1))
###
> MaxC(x: T.i4 * 2, 9 max #x)
MaxC(x : T.i4 * 2, 9 max #x) : {Count:i8, Max:i8}
Binder : MaxC(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: MaxC(*2: T, Max(9, #1))
###
> MinMaxC(x: T.i4 * 2, 9 max #x)
MinMaxC(x : T.i4 * 2, 9 max #x) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(*4: ForEach(*2: ForEach(*1: T, *1.i4), Mul(Num<i8>(*2), 2)), Max(9, #3))
Reducer: MinMaxC(*2: T, Max(9, #1))
###
> Sum(null)
Sum(null) : r8
Binder : Sum(null)
Reducer: 0
###
> Sum([])
Sum([]) : r8
Binder : Sum(null)
Reducer: 0
###
> Sum(vs) // Not necessarily empty, so doesn't reduce.
Sum(vs) : r8
Binder : Sum(ForEach(*1: vs, Unit<r8>(*1)))
Reducer: Sum(*1: vs, 0)
###
> Sum(null, 1)
Sum(null, 1) : i8
Binder : Sum(*1: null, 1)
Reducer: 0
###
> Sum([], 1)
Sum([], 1) : i8
Binder : Sum(*1: null, 1)
Reducer: 0
###
> Sum(vs, 1) // Not necessarily empty, so doesn't reduce.
Sum(vs, 1) : i8
Binder : Sum(*1: vs, 1)
###
> Sum(i8s->Take(0))
Sum(i8s->Take(0)) : i8
Binder : Sum(Take(i8s, 0))
Reducer: 0
###
> Sum(i8s->Take(0)->CastU2())
Sum(i8s->Take(0)->CastU2()) : i8
Binder : Sum(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: 0
###
> Sum(i8s->Take(0)->CastU8())
Sum(i8s->Take(0)->CastU8()) : u8
Binder : Sum(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: 0
###
> Sum(i8s->Take(0)->CastR8())
Sum(i8s->Take(0)->CastR8()) : r8
Binder : Sum(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: 0
###
> SumC(i8s->Take(0))
SumC(i8s->Take(0)) : {Count:i8, Sum:i8}
Binder : SumC(Take(i8s, 0))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(i8s->Take(0)->CastU2())
SumC(i8s->Take(0)->CastU2()) : {Count:i8, Sum:i8}
Binder : SumC(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(i8s->Take(0)->CastU8())
SumC(i8s->Take(0)->CastU8()) : {Count:i8, Sum:u8}
Binder : SumC(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: dflt<{Count:i8, Sum:u8}>
###
> SumC(i8s->Take(0)->CastR8())
SumC(i8s->Take(0)->CastR8()) : {Count:i8, Sum:r8}
Binder : SumC(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: dflt<{Count:i8, Sum:r8}>
###
> Sum(qi8s->Take(0))
Sum(qi8s->Take(0)) : i8
Binder : Sum(Take(qi8s, 0))
Reducer: 0
###
> Sum(qi8s->Take(0)->CastU2())
Sum(qi8s->Take(0)->CastU2()) : i8
Binder : Sum(ForEach(*1: Take(qi8s, 0), Guard(?2: *1, CastU2(?2))))
Reducer: 0
###
> Sum(qi8s->Take(0)->CastU8())
Sum(qi8s->Take(0)->CastU8()) : u8
Binder : Sum(ForEach(*1: Take(qi8s, 0), Guard(?2: *1, CastU8(?2))))
Reducer: 0
###
> Sum(qi8s->Take(0)->CastR8())
Sum(qi8s->Take(0)->CastR8()) : r8
Binder : Sum(ForEach(*1: Take(qi8s, 0), Guard(?2: *1, CastR8*(?2))))
Reducer: 0
###
> SumC(qi8s->Take(0))
SumC(qi8s->Take(0)) : {Count:i8, Sum:i8}
Binder : SumC(Take(qi8s, 0))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(qi8s->Take(0)->CastU2())
SumC(qi8s->Take(0)->CastU2()) : {Count:i8, Sum:i8}
Binder : SumC(ForEach(*1: Take(qi8s, 0), Guard(?2: *1, CastU2(?2))))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(qi8s->Take(0)->CastU8())
SumC(qi8s->Take(0)->CastU8()) : {Count:i8, Sum:u8}
Binder : SumC(ForEach(*1: Take(qi8s, 0), Guard(?2: *1, CastU8(?2))))
Reducer: dflt<{Count:i8, Sum:u8}>
###
> SumC(qi8s->Take(0)->CastR8())
SumC(qi8s->Take(0)->CastR8()) : {Count:i8, Sum:r8}
Binder : SumC(ForEach(*1: Take(qi8s, 0), Guard(?2: *1, CastR8*(?2))))
Reducer: dflt<{Count:i8, Sum:r8}>
###
> Mean(i8s->Take(0))
Mean(i8s->Take(0)) : r8
Binder : Mean(Take(i8s, 0))
Reducer: 0
###
> Mean(i8s->Take(0)->CastU2())
Mean(i8s->Take(0)->CastU2()) : r8
Binder : Mean(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: 0
###
> Mean(i8s->Take(0)->CastU8())
Mean(i8s->Take(0)->CastU8()) : r8
Binder : Mean(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: 0
###
> Mean(i8s->Take(0)->CastR8())
Mean(i8s->Take(0)->CastR8()) : r8
Binder : Mean(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: 0
###
> MeanC(i8s->Take(0))
MeanC(i8s->Take(0)) : {Count:i8, Mean:r8}
Binder : MeanC(Take(i8s, 0))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> MeanC(i8s->Take(0)->CastU2())
MeanC(i8s->Take(0)->CastU2()) : {Count:i8, Mean:r8}
Binder : MeanC(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> MeanC(i8s->Take(0)->CastU8())
MeanC(i8s->Take(0)->CastU8()) : {Count:i8, Mean:r8}
Binder : MeanC(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> MeanC(i8s->Take(0)->CastR8())
MeanC(i8s->Take(0)->CastR8()) : {Count:i8, Mean:r8}
Binder : MeanC(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> Min(i8s->Take(0))
Min(i8s->Take(0)) : i8
Binder : Min(Take(i8s, 0))
Reducer: 0
###
> Min(i8s->Take(0)->CastU2())
Min(i8s->Take(0)->CastU2()) : u2
Binder : Min(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: 0
###
> Min(i8s->Take(0)->CastU8())
Min(i8s->Take(0)->CastU8()) : u8
Binder : Min(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: 0
###
> Min(i8s->Take(0)->CastR8())
Min(i8s->Take(0)->CastR8()) : r8
Binder : Min(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: 0
###
> MinC(i8s->Take(0))
MinC(i8s->Take(0)) : {Count:i8, Min:i8}
Binder : MinC(Take(i8s, 0))
Reducer: dflt<{Count:i8, Min:i8}>
###
> MinC(i8s->Take(0)->CastU2())
MinC(i8s->Take(0)->CastU2()) : {Count:i8, Min:u2}
Binder : MinC(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: dflt<{Count:i8, Min:u2}>
###
> MinC(i8s->Take(0)->CastU8())
MinC(i8s->Take(0)->CastU8()) : {Count:i8, Min:u8}
Binder : MinC(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: dflt<{Count:i8, Min:u8}>
###
> MinC(i8s->Take(0)->CastR8())
MinC(i8s->Take(0)->CastR8()) : {Count:i8, Min:r8}
Binder : MinC(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: dflt<{Count:i8, Min:r8}>
###
> Max(i8s->Take(0))
Max(i8s->Take(0)) : i8
Binder : Max(Take(i8s, 0))
Reducer: 0
###
> Max(i8s->Take(0)->CastU2())
Max(i8s->Take(0)->CastU2()) : u2
Binder : Max(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: 0
###
> Max(i8s->Take(0)->CastU8())
Max(i8s->Take(0)->CastU8()) : u8
Binder : Max(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: 0
###
> Max(i8s->Take(0)->CastR8())
Max(i8s->Take(0)->CastR8()) : r8
Binder : Max(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: 0
###
> MaxC(i8s->Take(0))
MaxC(i8s->Take(0)) : {Count:i8, Max:i8}
Binder : MaxC(Take(i8s, 0))
Reducer: dflt<{Count:i8, Max:i8}>
###
> MaxC(i8s->Take(0)->CastU2())
MaxC(i8s->Take(0)->CastU2()) : {Count:i8, Max:u2}
Binder : MaxC(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: dflt<{Count:i8, Max:u2}>
###
> MaxC(i8s->Take(0)->CastU8())
MaxC(i8s->Take(0)->CastU8()) : {Count:i8, Max:u8}
Binder : MaxC(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: dflt<{Count:i8, Max:u8}>
###
> MaxC(i8s->Take(0)->CastR8())
MaxC(i8s->Take(0)->CastR8()) : {Count:i8, Max:r8}
Binder : MaxC(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: dflt<{Count:i8, Max:r8}>
###
> MinMax(i8s->Take(0))
MinMax(i8s->Take(0)) : {Max:i8, Min:i8}
Binder : MinMax(Take(i8s, 0))
Reducer: dflt<{Max:i8, Min:i8}>
###
> MinMax(i8s->Take(0)->CastU2())
MinMax(i8s->Take(0)->CastU2()) : {Max:u2, Min:u2}
Binder : MinMax(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: dflt<{Max:u2, Min:u2}>
###
> MinMax(i8s->Take(0)->CastU8())
MinMax(i8s->Take(0)->CastU8()) : {Max:u8, Min:u8}
Binder : MinMax(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: dflt<{Max:u8, Min:u8}>
###
> MinMax(i8s->Take(0)->CastR8())
MinMax(i8s->Take(0)->CastR8()) : {Max:r8, Min:r8}
Binder : MinMax(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: dflt<{Max:r8, Min:r8}>
###
> MinMaxC(i8s->Take(0))
MinMaxC(i8s->Take(0)) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(Take(i8s, 0))
Reducer: dflt<{Count:i8, Max:i8, Min:i8}>
###
> MinMaxC(i8s->Take(0)->CastU2())
MinMaxC(i8s->Take(0)->CastU2()) : {Count:i8, Max:u2, Min:u2}
Binder : MinMaxC(ForEach(*1: Take(i8s, 0), CastU2(*1)))
Reducer: dflt<{Count:i8, Max:u2, Min:u2}>
###
> MinMaxC(i8s->Take(0)->CastU8())
MinMaxC(i8s->Take(0)->CastU8()) : {Count:i8, Max:u8, Min:u8}
Binder : MinMaxC(ForEach(*1: Take(i8s, 0), CastU8(*1)))
Reducer: dflt<{Count:i8, Max:u8, Min:u8}>
###
> MinMaxC(i8s->Take(0)->CastR8())
MinMaxC(i8s->Take(0)->CastR8()) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(ForEach(*1: Take(i8s, 0), CastR8*(*1)))
Reducer: dflt<{Count:i8, Max:r8, Min:r8}>
###
> Sum(i8s->Take(0), it * it)
Sum(i8s->Take(0), it * it) : i8
Binder : Sum(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: 0
###
> Sum(i8s->Take(0), it->CastU2())
Sum(i8s->Take(0), it->CastU2()) : i8
Binder : Sum(*1: Take(i8s, 0), Num<i8>(CastU2(*1)))
Reducer: 0
###
> Sum(i8s->Take(0), it->CastU8())
Sum(i8s->Take(0), it->CastU8()) : u8
Binder : Sum(*1: Take(i8s, 0), CastU8(*1))
Reducer: 0
###
> Sum(i8s->Take(0), it->CastR8())
Sum(i8s->Take(0), it->CastR8()) : r8
Binder : Sum(*1: Take(i8s, 0), CastR8*(*1))
Reducer: 0
###
> SumC(i8s->Take(0), it * it)
SumC(i8s->Take(0), it * it) : {Count:i8, Sum:i8}
Binder : SumC(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(i8s->Take(0), it->CastU2())
SumC(i8s->Take(0), it->CastU2()) : {Count:i8, Sum:i8}
Binder : SumC(*1: Take(i8s, 0), Num<i8>(CastU2(*1)))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(i8s->Take(0), it->CastU8())
SumC(i8s->Take(0), it->CastU8()) : {Count:i8, Sum:u8}
Binder : SumC(*1: Take(i8s, 0), CastU8(*1))
Reducer: dflt<{Count:i8, Sum:u8}>
###
> SumC(i8s->Take(0), it->CastR8())
SumC(i8s->Take(0), it->CastR8()) : {Count:i8, Sum:r8}
Binder : SumC(*1: Take(i8s, 0), CastR8*(*1))
Reducer: dflt<{Count:i8, Sum:r8}>
###
> Sum(i8s->Take(0), Opt(it * it))
Sum(i8s->Take(0), Opt(it * it)) : i8
Binder : Sum(*1: Take(i8s, 0), Opt*(Mul(*1, *1)))
Reducer: 0
###
> Sum(i8s->Take(0), Opt(it->CastU2()))
Sum(i8s->Take(0), Opt(it->CastU2())) : i8
Binder : Sum(*1: Take(i8s, 0), Guard(?2: Opt*(CastU2(*1)), Num<i8>(?2)))
Reducer: 0
###
> Sum(i8s->Take(0), Opt(it->CastU8()))
Sum(i8s->Take(0), Opt(it->CastU8())) : u8
Binder : Sum(*1: Take(i8s, 0), Opt*(CastU8(*1)))
Reducer: 0
###
> Sum(i8s->Take(0), Opt(it->CastR8()))
Sum(i8s->Take(0), Opt(it->CastR8())) : r8
Binder : Sum(*1: Take(i8s, 0), Opt*(CastR8*(*1)))
Reducer: 0
###
> SumC(i8s->Take(0), Opt(it * it))
SumC(i8s->Take(0), Opt(it * it)) : {Count:i8, Sum:i8}
Binder : SumC(*1: Take(i8s, 0), Opt*(Mul(*1, *1)))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(i8s->Take(0), Opt(it->CastU2()))
SumC(i8s->Take(0), Opt(it->CastU2())) : {Count:i8, Sum:i8}
Binder : SumC(*1: Take(i8s, 0), Guard(?2: Opt*(CastU2(*1)), Num<i8>(?2)))
Reducer: dflt<{Count:i8, Sum:i8}>
###
> SumC(i8s->Take(0), Opt(it->CastU8()))
SumC(i8s->Take(0), Opt(it->CastU8())) : {Count:i8, Sum:u8}
Binder : SumC(*1: Take(i8s, 0), Opt*(CastU8(*1)))
Reducer: dflt<{Count:i8, Sum:u8}>
###
> SumC(i8s->Take(0), Opt(it->CastR8()))
SumC(i8s->Take(0), Opt(it->CastR8())) : {Count:i8, Sum:r8}
Binder : SumC(*1: Take(i8s, 0), Opt*(CastR8*(*1)))
Reducer: dflt<{Count:i8, Sum:r8}>
###
> Mean(i8s->Take(0), it * it)
Mean(i8s->Take(0), it * it) : r8
Binder : Mean(*1: Take(i8s, 0), Num<r8>(Mul(*1, *1)))
Reducer: 0
###
> Mean(i8s->Take(0), it->CastU2())
Mean(i8s->Take(0), it->CastU2()) : r8
Binder : Mean(*1: Take(i8s, 0), Num<r8>(CastU2(*1)))
Reducer: 0
###
> Mean(i8s->Take(0), it->CastU8())
Mean(i8s->Take(0), it->CastU8()) : r8
Binder : Mean(*1: Take(i8s, 0), Num<r8>(CastU8(*1)))
Reducer: 0
###
> Mean(i8s->Take(0), it->CastR8())
Mean(i8s->Take(0), it->CastR8()) : r8
Binder : Mean(*1: Take(i8s, 0), CastR8*(*1))
Reducer: 0
###
> MeanC(i8s->Take(0), it * it)
MeanC(i8s->Take(0), it * it) : {Count:i8, Mean:r8}
Binder : MeanC(*1: Take(i8s, 0), Num<r8>(Mul(*1, *1)))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> MeanC(i8s->Take(0), it->CastU2())
MeanC(i8s->Take(0), it->CastU2()) : {Count:i8, Mean:r8}
Binder : MeanC(*1: Take(i8s, 0), Num<r8>(CastU2(*1)))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> MeanC(i8s->Take(0), it->CastU8())
MeanC(i8s->Take(0), it->CastU8()) : {Count:i8, Mean:r8}
Binder : MeanC(*1: Take(i8s, 0), Num<r8>(CastU8(*1)))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> MeanC(i8s->Take(0), it->CastR8())
MeanC(i8s->Take(0), it->CastR8()) : {Count:i8, Mean:r8}
Binder : MeanC(*1: Take(i8s, 0), CastR8*(*1))
Reducer: dflt<{Count:i8, Mean:r8}>
###
> Min(i8s->Take(0), it * it)
Min(i8s->Take(0), it * it) : i8
Binder : Min(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: 0
###
> Min(i8s->Take(0), it->CastU2())
Min(i8s->Take(0), it->CastU2()) : u2
Binder : Min(*1: Take(i8s, 0), CastU2(*1))
Reducer: 0
###
> Min(i8s->Take(0), it->CastU8())
Min(i8s->Take(0), it->CastU8()) : u8
Binder : Min(*1: Take(i8s, 0), CastU8(*1))
Reducer: 0
###
> Min(i8s->Take(0), it->CastR8())
Min(i8s->Take(0), it->CastR8()) : r8
Binder : Min(*1: Take(i8s, 0), CastR8*(*1))
Reducer: 0
###
> MinC(i8s->Take(0), it * it)
MinC(i8s->Take(0), it * it) : {Count:i8, Min:i8}
Binder : MinC(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: dflt<{Count:i8, Min:i8}>
###
> MinC(i8s->Take(0), it->CastU2())
MinC(i8s->Take(0), it->CastU2()) : {Count:i8, Min:u2}
Binder : MinC(*1: Take(i8s, 0), CastU2(*1))
Reducer: dflt<{Count:i8, Min:u2}>
###
> MinC(i8s->Take(0), it->CastU8())
MinC(i8s->Take(0), it->CastU8()) : {Count:i8, Min:u8}
Binder : MinC(*1: Take(i8s, 0), CastU8(*1))
Reducer: dflt<{Count:i8, Min:u8}>
###
> MinC(i8s->Take(0), it->CastR8())
MinC(i8s->Take(0), it->CastR8()) : {Count:i8, Min:r8}
Binder : MinC(*1: Take(i8s, 0), CastR8*(*1))
Reducer: dflt<{Count:i8, Min:r8}>
###
> Max(i8s->Take(0), it * it)
Max(i8s->Take(0), it * it) : i8
Binder : Max(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: 0
###
> Max(i8s->Take(0), it->CastU2())
Max(i8s->Take(0), it->CastU2()) : u2
Binder : Max(*1: Take(i8s, 0), CastU2(*1))
Reducer: 0
###
> Max(i8s->Take(0), it->CastU8())
Max(i8s->Take(0), it->CastU8()) : u8
Binder : Max(*1: Take(i8s, 0), CastU8(*1))
Reducer: 0
###
> Max(i8s->Take(0), it->CastR8())
Max(i8s->Take(0), it->CastR8()) : r8
Binder : Max(*1: Take(i8s, 0), CastR8*(*1))
Reducer: 0
###
> MaxC(i8s->Take(0), it * it)
MaxC(i8s->Take(0), it * it) : {Count:i8, Max:i8}
Binder : MaxC(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: dflt<{Count:i8, Max:i8}>
###
> MaxC(i8s->Take(0), it->CastU2())
MaxC(i8s->Take(0), it->CastU2()) : {Count:i8, Max:u2}
Binder : MaxC(*1: Take(i8s, 0), CastU2(*1))
Reducer: dflt<{Count:i8, Max:u2}>
###
> MaxC(i8s->Take(0), it->CastU8())
MaxC(i8s->Take(0), it->CastU8()) : {Count:i8, Max:u8}
Binder : MaxC(*1: Take(i8s, 0), CastU8(*1))
Reducer: dflt<{Count:i8, Max:u8}>
###
> MaxC(i8s->Take(0), it->CastR8())
MaxC(i8s->Take(0), it->CastR8()) : {Count:i8, Max:r8}
Binder : MaxC(*1: Take(i8s, 0), CastR8*(*1))
Reducer: dflt<{Count:i8, Max:r8}>
###
> MinMax(i8s->Take(0), it * it)
MinMax(i8s->Take(0), it * it) : {Max:i8, Min:i8}
Binder : MinMax(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: dflt<{Max:i8, Min:i8}>
###
> MinMax(i8s->Take(0), it->CastU2())
MinMax(i8s->Take(0), it->CastU2()) : {Max:u2, Min:u2}
Binder : MinMax(*1: Take(i8s, 0), CastU2(*1))
Reducer: dflt<{Max:u2, Min:u2}>
###
> MinMax(i8s->Take(0), it->CastU8())
MinMax(i8s->Take(0), it->CastU8()) : {Max:u8, Min:u8}
Binder : MinMax(*1: Take(i8s, 0), CastU8(*1))
Reducer: dflt<{Max:u8, Min:u8}>
###
> MinMax(i8s->Take(0), it->CastR8())
MinMax(i8s->Take(0), it->CastR8()) : {Max:r8, Min:r8}
Binder : MinMax(*1: Take(i8s, 0), CastR8*(*1))
Reducer: dflt<{Max:r8, Min:r8}>
###
> MinMaxC(i8s->Take(0), it * it)
MinMaxC(i8s->Take(0), it * it) : {Count:i8, Max:i8, Min:i8}
Binder : MinMaxC(*1: Take(i8s, 0), Mul(*1, *1))
Reducer: dflt<{Count:i8, Max:i8, Min:i8}>
###
> MinMaxC(i8s->Take(0), it->CastU2())
MinMaxC(i8s->Take(0), it->CastU2()) : {Count:i8, Max:u2, Min:u2}
Binder : MinMaxC(*1: Take(i8s, 0), CastU2(*1))
Reducer: dflt<{Count:i8, Max:u2, Min:u2}>
###
> MinMaxC(i8s->Take(0), it->CastU8())
MinMaxC(i8s->Take(0), it->CastU8()) : {Count:i8, Max:u8, Min:u8}
Binder : MinMaxC(*1: Take(i8s, 0), CastU8(*1))
Reducer: dflt<{Count:i8, Max:u8, Min:u8}>
###
> MinMaxC(i8s->Take(0), it->CastR8())
MinMaxC(i8s->Take(0), it->CastR8()) : {Count:i8, Max:r8, Min:r8}
Binder : MinMaxC(*1: Take(i8s, 0), CastR8*(*1))
Reducer: dflt<{Count:i8, Max:r8, Min:r8}>
###
> Sum(T, s)
Sum(T, s) : r8
*** Error: (7,8) Node: s, Message: Invalid operand type: cannot convert type 's' to 'r8?'
Binder : Sum(*1: T, Error(ErrBadType_Src_Dst))
###
> Sum(T.s)
Sum(T.s) : r8
*** Error: (5,6) Node: T.s, Message: Invalid operand type: cannot convert type 's*' to 'r8?*'
Binder : Sum(Error(ErrBadType_Src_Dst))
###
> Sum(T)
Sum(T) : r8
*** Error: (4,5) Node: T, Message: Invalid operand type: cannot convert type '{b:b, i:i, i1:i1, i2:i2, i4:i4, i8:i8, n:r8, qb:b?, qi:i?, qi1:i1?, qi2:i2?, qi4:i4?, qi8:i8?, qn:r8?, qr4:r4?, qr8:r8?, qu1:u1?, qu2:u2?, qu4:u4?, qu8:u8?, r4:r4, r8:r8, s:s, u1:u1, u2:u2, u4:u4, u8:u8}*' to 'r8*'
Binder : Sum(Error(ErrBadType_Src_Dst))
###
> Sum(R)
Sum(R) : r8
*** Error: (4,5) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'r8*'
Binder : Sum(Error(ErrBadType_Src_Dst))
###
> Sum(R.A)
Sum(R.A) : i8
*** Error: (5,6) Node: R.A, Message: Invalid operand type: cannot convert type 'i4' to 'i4*'
Binder : Sum(Error(ErrBadType_Src_Dst))
###
> Sum(T, R, n * A)
Sum(T, R, n * A) : r8
*** Error: (7,8) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to '{A:i4}*'
Binder : Sum(*1: T, *2: Error(ErrBadType_Src_Dst), Mul(*1.n, Num<r8>(*2.A)))
Reducer: Sum(ForEach(*1: T, *2: Error(ErrBadType_Src_Dst), Mul(*1.n, Num<r8>(*2.A))))
###

**** New globals: {A:i4*, B:i4*, C:i4*, D:i4*, E:i4*}

> Sum(a:A, b:B, c:C, d:D, e:E, a*b*c*d*e)
Sum(a : A, b : B, c : C, d : D, e : E, a * b * c * d * e) : i8
Binder : Sum(*1: A, *2: B, *3: C, *4: D, *5: E, Mul(Num<i8>(*1), Num<i8>(*2), Num<i8>(*3), Num<i8>(*4), Num<i8>(*5)))
Reducer: Sum(ForEach(*1: A, *2: B, *3: C, *4: D, *5: E, Mul(Num<i8>(*1), Num<i8>(*2), Num<i8>(*3), Num<i8>(*4), Num<i8>(*5))))
###
> SumBig(a:A, b:B, c:C, d:D, e:E, a*b*c*d*e)
SumBig(a : A, b : B, c : C, d : D, e : E, a * b * c * d * e) : i
Binder : SumBig(*1: A, *2: B, *3: C, *4: D, *5: E, Num<i>(Mul(Num<i8>(*1), Num<i8>(*2), Num<i8>(*3), Num<i8>(*4), Num<i8>(*5))))
Reducer: SumBig(ForEach(*1: A, *2: B, *3: C, *4: D, *5: E, Num<i>(Mul(Num<i8>(*1), Num<i8>(*2), Num<i8>(*3), Num<i8>(*4), Num<i8>(*5)))))
###
> Sum(ForEach(a:A, [if] a > 1, it + 1))
Sum(ForEach(a : A, [if] a $> 1, it + 1)) : i8
Binder : Sum(ForEach(*1: A, [if] Num<i8>(*1) @> 1, Add(Num<i8>(*1), 1)))
###
> Sum(ForEach(a:A, [while] a > 1, it + 1))
Sum(ForEach(a : A, [while] a $> 1, it + 1)) : i8
Binder : Sum(ForEach(*1: A, [while] Num<i8>(*1) @> 1, Add(Num<i8>(*1), 1)))
###
> Sum(ForEachIf(a:A, a > 1, it + 1))
Sum(ForEachIf(a : A, a $> 1, it + 1)) : i8
Binder : Sum(ForEachIf*(*1: A, Num<i8>(*1) @> 1, Add(Num<i8>(*1), 1)))
Reducer: Sum(ForEach(*1: A, [if] Num<i8>(*1) @> 1, Add(Num<i8>(*1), 1)))
###
> Sum(ForEachWhile(a:A, a > 1, it + 1))
Sum(ForEachWhile(a : A, a $> 1, it + 1)) : i8
Binder : Sum(ForEachWhile*(*1: A, Num<i8>(*1) @> 1, Add(Num<i8>(*1), 1)))
Reducer: Sum(ForEach(*1: A, [while] Num<i8>(*1) @> 1, Add(Num<i8>(*1), 1)))
###
