**** New definitions: Vals, type: g*
**** New definitions: Recs, type: g*
**** New udf: TF, arity: 1
**** New udf: TF, arity: 2
**** New udf: TF, arity: 3
**** New definitions: Tens, type: g*
**** New udf: L, arity: 2

> Vals->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Vals->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8?, i8?, r8?, b?, b?)?*
BndKind:Call, Type:(s, i8?, i8?, r8?, b?, b?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Vals), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), null:r8?):r8?), Call(∂.LikeOrVal(Scope(2), null:b?):b?), Call(∂.LikeOrVal(Scope(2), null:b?):b?)):(s, i8?, i8?, r8?, b?, b?)):(s, i8?, i8?, r8?, b?, b?)?)):(s, i8?, i8?, r8?, b?, b?)?*))
Func sig: (Vals:g*) to (s, i8?, i8?, r8?, b?, b?)?*
Sequence: Seq<(str,Opt<i8>,Opt<i8>,Opt<r8>,Opt<bool>,Opt<bool>)>
 0) (Values, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, 3, 3, <null>, <null>, <null>)
 2) (<null>, <null>, <null>, 7.5, <null>, <null>)
 3) (<null>, <null>, <null>, <null>, true , true )
###
> Recs->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Recs->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8?, i8?, r8?, b?, b?)?*
BndKind:Call, Type:(s, i8?, i8?, r8?, b?, b?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Recs), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), null:r8?):r8?), Call(∂.LikeOrVal(Scope(2), null:b?):b?), Call(∂.LikeOrVal(Scope(2), null:b?):b?)):(s, i8?, i8?, r8?, b?, b?)):(s, i8?, i8?, r8?, b?, b?)?)):(s, i8?, i8?, r8?, b?, b?)?*))
Func sig: (Recs:g*) to (s, i8?, i8?, r8?, b?, b?)?*
Sequence: Seq<(str,Opt<i8>,Opt<i8>,Opt<r8>,Opt<bool>,Opt<bool>)>
 0) (Record, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, <null>, <null>, <null>, <null>, <null>)
 2) (<null>, <null>, <null>, <null>, <null>, <null>)
 3) (<null>, <null>, <null>, <null>, <null>, <null>)
 4) (<null>, <null>, <null>, <null>, <null>, <null>)
 5) (<null>, <null>, <null>, <null>, <null>, <null>)
###
> Tens->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Tens->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8?, i8?, r8?, b?, b?)?*
BndKind:Call, Type:(s, i8?, i8?, r8?, b?, b?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Tens), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), null:r8?):r8?), Call(∂.LikeOrVal(Scope(2), null:b?):b?), Call(∂.LikeOrVal(Scope(2), null:b?):b?)):(s, i8?, i8?, r8?, b?, b?)):(s, i8?, i8?, r8?, b?, b?)?)):(s, i8?, i8?, r8?, b?, b?)?*))
Func sig: (Tens:g*) to (s, i8?, i8?, r8?, b?, b?)?*
Sequence: Seq<(str,Opt<i8>,Opt<i8>,Opt<r8>,Opt<bool>,Opt<bool>)>
 0) (Tensor, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, <null>, <null>, <null>, <null>, <null>)
 2) (<null>, <null>, <null>, <null>, <null>, <null>)
 3) (<null>, <null>, <null>, <null>, <null>, <null>)
 4) (<null>, <null>, <null>, <null>, <null>, <null>)
 5) (<null>, <null>, <null>, <null>, <null>, <null>)
###
> Vals->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Vals->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*
BndKind:Call, Type:(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Vals), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:{A:i8}?)), Call(∂.LikeOrVal(Scope(2), null:{B:i8}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i8, B:b}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i8, B:b?}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i4}?))):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?)):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*))
Func sig: (Vals:g*) to (s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Values, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, <null>, <null>, <null>, <null>, <null>)
 2) (<null>, <null>, <null>, <null>, <null>, <null>)
 3) (<null>, <null>, <null>, <null>, <null>, <null>)
###
> Recs->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Recs->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*
BndKind:Call, Type:(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Recs), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:{A:i8}?)), Call(∂.LikeOrVal(Scope(2), null:{B:i8}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i8, B:b}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i8, B:b?}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i4}?))):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?)):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*))
Func sig: (Recs:g*) to (s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Record, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, { A: 3 }, <null>, <null>, <null>, <null>)
 2) (<null>, <null>, { B: 3 }, <null>, <null>, <null>)
 3) (<null>, <null>, <null>, { A: 3, B: true  }, { A: 3, B: true  }, <null>)
 4) (<null>, <null>, <null>, <null>, { A: 3, B: <null> }, <null>)
 5) (<null>, <null>, <null>, <null>, <null>, { A: 3 })
###
> Tens->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Tens->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*
BndKind:Call, Type:(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Tens), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:{A:i8}?)), Call(∂.LikeOrVal(Scope(2), null:{B:i8}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i8, B:b}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i8, B:b?}?)), Call(∂.LikeOrVal(Scope(2), null:{A:i4}?))):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?)):(s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*))
Func sig: (Tens:g*) to (s, {A:i8}?, {B:i8}?, {A:i8, B:b}?, {A:i8, B:b?}?, {A:i4}?)?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Tensor, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, <null>, <null>, <null>, <null>, <null>)
 2) (<null>, <null>, <null>, <null>, <null>, <null>)
 3) (<null>, <null>, <null>, <null>, <null>, <null>)
 4) (<null>, <null>, <null>, <null>, <null>, <null>)
 5) (<null>, <null>, <null>, <null>, <null>, <null>)
###
> Vals->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Vals->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*
BndKind:Call, Type:(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Vals), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), null:i8[*]?):i8[*]?), Call(∂.LikeOrVal(Scope(2), null:r8[*]?):r8[*]?), Call(∂.LikeOrVal(Scope(2), null:i8[*,*]?):i8[*,*]?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*))
Func sig: (Vals:g*) to (s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Values, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, <null>, <null>, <null>, <null>, <null>)
 2) (<null>, <null>, <null>, <null>, <null>, <null>)
 3) (<null>, <null>, <null>, <null>, <null>, <null>)
###
> Recs->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Recs->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*
BndKind:Call, Type:(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Recs), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), null:i8[*]?):i8[*]?), Call(∂.LikeOrVal(Scope(2), null:r8[*]?):r8[*]?), Call(∂.LikeOrVal(Scope(2), null:i8[*,*]?):i8[*,*]?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*))
Func sig: (Recs:g*) to (s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Record, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, <null>, <null>, <null>, <null>, <null>)
 2) (<null>, <null>, <null>, <null>, <null>, <null>)
 3) (<null>, <null>, <null>, <null>, <null>, <null>)
 4) (<null>, <null>, <null>, <null>, <null>, <null>)
 5) (<null>, <null>, <null>, <null>, <null>, <null>)
###
> Tens->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Tens->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*
BndKind:Call, Type:(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*, Bnd:(Call(∂.ForEach([map:1] Global(Tens), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), null:i8[*]?):i8[*]?), Call(∂.LikeOrVal(Scope(2), null:r8[*]?):r8[*]?), Call(∂.LikeOrVal(Scope(2), null:i8[*,*]?):i8[*,*]?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?)):(s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*))
Func sig: (Tens:g*) to (s, i8[]?, i8[]?, i8[*]?, r8[*]?, i8[*,*]?)?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Tensor, <null>, <null>, <null>, <null>, <null>)
 1) (<null>, Ten<i8>()<> [1], Ten<i8>()<> [1], <null>, <null>, <null>)
 2) (<null>, Ten<i8>()<> [2], Ten<i8>()<> [2], <null>, <null>, <null>)
 3) (<null>, <null>, <null>, Ten<i8>(3)<0> [3, 3, 3], <null>, <null>)
 4) (<null>, <null>, <null>, <null>, Ten<r8>(3)<0> [5.5, 5.5, 5.5], <null>)
 5) (<null>, <null>, <null>, <null>, <null>, Ten<i8>(2,2)<0,0>
          [[4, 4]
           [4, 4]]
    )
###

**** Redefined udf: L, arity: 2

> Vals->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Vals->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8, i8?, r8, b, b)?*
BndKind:Call, Type:(s, i8, i8?, r8, b, b)?*, Bnd:(Call(∂.ForEach([map:1] Global(Vals), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), 0:i8):i8), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), 0:r8):r8), Call(∂.LikeOrVal(Scope(2), false:b):b), Call(∂.LikeOrVal(Scope(2), false:b):b)):(s, i8, i8?, r8, b, b)):(s, i8, i8?, r8, b, b)?)):(s, i8, i8?, r8, b, b)?*))
Func sig: (Vals:g*) to (s, i8, i8?, r8, b, b)?*
Sequence: Seq<(str,i8,Opt<i8>,r8,bool,bool)>
 0) (Values, 0, <null>, 0, false, false)
 1) (<null>, 3, 3, 0, false, false)
 2) (<null>, 0, <null>, 7.5, false, false)
 3) (<null>, 0, <null>, 0, true , true )
###
> Recs->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Recs->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8, i8?, r8, b, b)?*
BndKind:Call, Type:(s, i8, i8?, r8, b, b)?*, Bnd:(Call(∂.ForEach([map:1] Global(Recs), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), 0:i8):i8), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), 0:r8):r8), Call(∂.LikeOrVal(Scope(2), false:b):b), Call(∂.LikeOrVal(Scope(2), false:b):b)):(s, i8, i8?, r8, b, b)):(s, i8, i8?, r8, b, b)?)):(s, i8, i8?, r8, b, b)?*))
Func sig: (Recs:g*) to (s, i8, i8?, r8, b, b)?*
Sequence: Seq<(str,i8,Opt<i8>,r8,bool,bool)>
 0) (Record, 0, <null>, 0, false, false)
 1) (<null>, 0, <null>, 0, false, false)
 2) (<null>, 0, <null>, 0, false, false)
 3) (<null>, 0, <null>, 0, false, false)
 4) (<null>, 0, <null>, 0, false, false)
 5) (<null>, 0, <null>, 0, false, false)
###
> Tens->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Tens->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8, i8?, r8, b, b)?*
BndKind:Call, Type:(s, i8, i8?, r8, b, b)?*, Bnd:(Call(∂.ForEach([map:1] Global(Tens), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), 0:i8):i8), Call(∂.LikeOrVal(Scope(2), null:i8?):i8?), Call(∂.LikeOrVal(Scope(2), 0:r8):r8), Call(∂.LikeOrVal(Scope(2), false:b):b), Call(∂.LikeOrVal(Scope(2), false:b):b)):(s, i8, i8?, r8, b, b)):(s, i8, i8?, r8, b, b)?)):(s, i8, i8?, r8, b, b)?*))
Func sig: (Tens:g*) to (s, i8, i8?, r8, b, b)?*
Sequence: Seq<(str,i8,Opt<i8>,r8,bool,bool)>
 0) (Tensor, 0, <null>, 0, false, false)
 1) (<null>, 0, <null>, 0, false, false)
 2) (<null>, 0, <null>, 0, false, false)
 3) (<null>, 0, <null>, 0, false, false)
 4) (<null>, 0, <null>, 0, false, false)
 5) (<null>, 0, <null>, 0, false, false)
###
> Vals->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Vals->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
BndKind:Call, Type:(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*, Bnd:(Call(∂.ForEach([map:1] Global(Vals), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8}>)), Call(∂.LikeOrVal(Scope(2), dflt<{B:i8}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8, B:b}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8, B:b?}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i4}>))):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*))
Func sig: (Vals:g*) to (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Values, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 1) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 2) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 3) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
###
> Recs->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Recs->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
BndKind:Call, Type:(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*, Bnd:(Call(∂.ForEach([map:1] Global(Recs), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8}>)), Call(∂.LikeOrVal(Scope(2), dflt<{B:i8}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8, B:b}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8, B:b?}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i4}>))):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*))
Func sig: (Recs:g*) to (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Record, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 1) (<null>, { A: 3 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 2) (<null>, { A: 0 }, { B: 3 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 3) (<null>, { A: 0 }, { B: 0 }, { A: 3, B: true  }, { A: 3, B: true  }, { A: 0 })
 4) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 3, B: <null> }, { A: 0 })
 5) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 3 })
###
> Tens->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Tens->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
BndKind:Call, Type:(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*, Bnd:(Call(∂.ForEach([map:1] Global(Tens), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8}>)), Call(∂.LikeOrVal(Scope(2), dflt<{B:i8}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8, B:b}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i8, B:b?}>)), Call(∂.LikeOrVal(Scope(2), dflt<{A:i4}>))):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*))
Func sig: (Tens:g*) to (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Tensor, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 1) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 2) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 3) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 4) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
 5) (<null>, { A: 0 }, { B: 0 }, { A: 0, B: false }, { A: 0, B: <null> }, { A: 0 })
###
> Vals->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Vals->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
BndKind:Call, Type:(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*, Bnd:(Call(∂.ForEach([map:1] Global(Vals), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), dflt<i8[]>):i8[]), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), dflt<i8[*]>):i8[*]), Call(∂.LikeOrVal(Scope(2), dflt<r8[*]>):r8[*]), Call(∂.LikeOrVal(Scope(2), dflt<i8[*,*]>):i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*))
Func sig: (Vals:g*) to (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Values, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 1) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 2) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 3) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
###
> Recs->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Recs->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
BndKind:Call, Type:(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*, Bnd:(Call(∂.ForEach([map:1] Global(Recs), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), dflt<i8[]>):i8[]), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), dflt<i8[*]>):i8[*]), Call(∂.LikeOrVal(Scope(2), dflt<r8[*]>):r8[*]), Call(∂.LikeOrVal(Scope(2), dflt<i8[*,*]>):i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*))
Func sig: (Recs:g*) to (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Record, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 1) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 2) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 3) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 4) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 5) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
###
> Tens->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Tens->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
BndKind:Call, Type:(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*, Bnd:(Call(∂.ForEach([map:1] Global(Tens), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str(<null>)):s), Call(∂.LikeOrVal(Scope(2), dflt<i8[]>):i8[]), Call(∂.LikeOrVal(Scope(2), null:i8[]?):i8[]?), Call(∂.LikeOrVal(Scope(2), dflt<i8[*]>):i8[*]), Call(∂.LikeOrVal(Scope(2), dflt<r8[*]>):r8[*]), Call(∂.LikeOrVal(Scope(2), dflt<i8[*,*]>):i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*))
Func sig: (Tens:g*) to (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Tensor, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 1) (<null>, Ten<i8>()<> [1], Ten<i8>()<> [1], Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 2) (<null>, Ten<i8>()<> [2], Ten<i8>()<> [2], Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 3) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(3)<0> [3, 3, 3], Ten<r8>(0)<0> [], Ten<i8>(0,0)<0,0> [])
 4) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(3)<0> [5.5, 5.5, 5.5], Ten<i8>(0,0)<0,0> [])
 5) (<null>, Ten<i8>()<> [0], <null>, Ten<i8>(0)<0> [], Ten<r8>(0)<0> [], Ten<i8>(2,2)<0,0>
          [[4, 4]
           [4, 4]]
    )
###

**** Redefined udf: L, arity: 2

> Vals->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Vals->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8, i8?, r8, b, b)?*
BndKind:Call, Type:(s, i8, i8?, r8, b, b)?*, Bnd:(Call(∂.ForEach([map:1] Global(Vals), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str()):s), Call(∂.LikeOrVal(Scope(2), -1:i8):i8), Call(∂.LikeOrVal(Scope(2), Opt<i8?>(-1:i8)):i8?), Call(∂.LikeOrVal(Scope(2), -1:r8):r8), Call(∂.LikeOrVal(Scope(2), false:b):b), Call(∂.LikeOrVal(Scope(2), true:b):b)):(s, i8, i8?, r8, b, b)):(s, i8, i8?, r8, b, b)?)):(s, i8, i8?, r8, b, b)?*))
Func sig: (Vals:g*) to (s, i8, i8?, r8, b, b)?*
Sequence: Seq<(str,i8,Opt<i8>,r8,bool,bool)>
 0) (Values, -1, -1, -1, false, true )
 1) (, 3, 3, -1, false, true )
 2) (, -1, -1, 7.5, false, true )
 3) (, -1, -1, -1, true , true )
###
> Recs->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Recs->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8, i8?, r8, b, b)?*
BndKind:Call, Type:(s, i8, i8?, r8, b, b)?*, Bnd:(Call(∂.ForEach([map:1] Global(Recs), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str()):s), Call(∂.LikeOrVal(Scope(2), -1:i8):i8), Call(∂.LikeOrVal(Scope(2), Opt<i8?>(-1:i8)):i8?), Call(∂.LikeOrVal(Scope(2), -1:r8):r8), Call(∂.LikeOrVal(Scope(2), false:b):b), Call(∂.LikeOrVal(Scope(2), true:b):b)):(s, i8, i8?, r8, b, b)):(s, i8, i8?, r8, b, b)?)):(s, i8, i8?, r8, b, b)?*))
Func sig: (Recs:g*) to (s, i8, i8?, r8, b, b)?*
Sequence: Seq<(str,i8,Opt<i8>,r8,bool,bool)>
 0) (Record, -1, -1, -1, false, true )
 1) (, -1, -1, -1, false, true )
 2) (, -1, -1, -1, false, true )
 3) (, -1, -1, -1, false, true )
 4) (, -1, -1, -1, false, true )
 5) (, -1, -1, -1, false, true )
###
> Tens->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1.0), it->L(false), it->L(true))
Tens->(it->L(""), it->L(-1), it->L(Opt(-1)), it->L(-1), it->L(false), it->L(true)) : (s, i8, i8?, r8, b, b)?*
BndKind:Call, Type:(s, i8, i8?, r8, b, b)?*, Bnd:(Call(∂.ForEach([map:1] Global(Tens), Call(∂.Guard([guard:2] Scope(1), (Call(∂.LikeOrVal(Scope(2), str()):s), Call(∂.LikeOrVal(Scope(2), -1:i8):i8), Call(∂.LikeOrVal(Scope(2), Opt<i8?>(-1:i8)):i8?), Call(∂.LikeOrVal(Scope(2), -1:r8):r8), Call(∂.LikeOrVal(Scope(2), false:b):b), Call(∂.LikeOrVal(Scope(2), true:b):b)):(s, i8, i8?, r8, b, b)):(s, i8, i8?, r8, b, b)?)):(s, i8, i8?, r8, b, b)?*))
Func sig: (Tens:g*) to (s, i8, i8?, r8, b, b)?*
Sequence: Seq<(str,i8,Opt<i8>,r8,bool,bool)>
 0) (Tensor, -1, -1, -1, false, true )
 1) (, -1, -1, -1, false, true )
 2) (, -1, -1, -1, false, true )
 3) (, -1, -1, -1, false, true )
 4) (, -1, -1, -1, false, true )
 5) (, -1, -1, -1, false, true )
###
> Vals->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Vals->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
BndKind:Call, Type:(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*, Bnd:(Call(∂.With([with:1] {A:-1:i8}, [with:2] {B:-1:i8}, [with:3] {A:-1:i8, B:true:b}, [with:4] {A:-1:i8, B:Opt<b?>(false:b)}, [with:5] {A:-1:i4}, Call(∂.ForEach([map:6] Global(Vals), Call(∂.Guard([guard:7] Scope(6), (Call(∂.LikeOrVal(Scope(7), str()):s), Call(∂.LikeOrVal(Scope(7), Scope(1))), Call(∂.LikeOrVal(Scope(7), Scope(2))), Call(∂.LikeOrVal(Scope(7), Scope(3))), Call(∂.LikeOrVal(Scope(7), Scope(4))), Call(∂.LikeOrVal(Scope(7), Scope(5)))):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*))
Func sig: (Vals:g*) to (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Values, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 1) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 2) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 3) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
###
> Recs->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Recs->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
BndKind:Call, Type:(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*, Bnd:(Call(∂.With([with:1] {A:-1:i8}, [with:2] {B:-1:i8}, [with:3] {A:-1:i8, B:true:b}, [with:4] {A:-1:i8, B:Opt<b?>(false:b)}, [with:5] {A:-1:i4}, Call(∂.ForEach([map:6] Global(Recs), Call(∂.Guard([guard:7] Scope(6), (Call(∂.LikeOrVal(Scope(7), str()):s), Call(∂.LikeOrVal(Scope(7), Scope(1))), Call(∂.LikeOrVal(Scope(7), Scope(2))), Call(∂.LikeOrVal(Scope(7), Scope(3))), Call(∂.LikeOrVal(Scope(7), Scope(4))), Call(∂.LikeOrVal(Scope(7), Scope(5)))):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*))
Func sig: (Recs:g*) to (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Record, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 1) (, { A: 3 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 2) (, { A: -1 }, { B: 3 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 3) (, { A: -1 }, { B: -1 }, { A: 3, B: true  }, { A: 3, B: true  }, { A: -1 })
 4) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: 3, B: <null> }, { A: -1 })
 5) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: 3 })
###
> Tens->(it->L(""), it->L({A:-1}), it->L({B:-1}), it->L({A:-1, B:true}), it->L({A:-1, B:Opt(false)}), it->L({A:-1i4}))
Tens->(it->L(""), it->L({ A : -1 }), it->L({ B : -1 }), it->L({ A : -1, B : true }), it->L({ A : -1, B : Opt(false) }), it->L({ A : -1 })) : (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
BndKind:Call, Type:(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*, Bnd:(Call(∂.With([with:1] {A:-1:i8}, [with:2] {B:-1:i8}, [with:3] {A:-1:i8, B:true:b}, [with:4] {A:-1:i8, B:Opt<b?>(false:b)}, [with:5] {A:-1:i4}, Call(∂.ForEach([map:6] Global(Tens), Call(∂.Guard([guard:7] Scope(6), (Call(∂.LikeOrVal(Scope(7), str()):s), Call(∂.LikeOrVal(Scope(7), Scope(1))), Call(∂.LikeOrVal(Scope(7), Scope(2))), Call(∂.LikeOrVal(Scope(7), Scope(3))), Call(∂.LikeOrVal(Scope(7), Scope(4))), Call(∂.LikeOrVal(Scope(7), Scope(5)))):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*)):(s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*))
Func sig: (Tens:g*) to (s, {A:i8}, {B:i8}, {A:i8, B:b}, {A:i8, B:b?}, {A:i4})?*
Sequence: Seq<(str,{i8},{i8},{i8,bool},{i8,bool},{i4})>
 0) (Tensor, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 1) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 2) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 3) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 4) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
 5) (, { A: -1 }, { B: -1 }, { A: -1, B: true  }, { A: -1, B: false }, { A: -1 })
###
> Vals->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Vals->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
BndKind:Call, Type:(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*, Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(-1:i8):i8[]), [with:2] Ref<i8[]?>(Call(∂.Tensor.Fill(-1:i8):i8[])), [with:3] Call(∂.Tensor.Fill(-1:i8, 1:i8):i8[*]), [with:4] Call(∂.Tensor.Fill(-1:r8, 1:i8):r8[*]), [with:5] Call(∂.Tensor.Fill(-1:i8, 1:i8, 1:i8):i8[*,*]), Call(∂.ForEach([map:6] Global(Vals), Call(∂.Guard([guard:7] Scope(6), (Call(∂.LikeOrVal(Scope(7), str()):s), Call(∂.LikeOrVal(Scope(7), Scope(1)):i8[]), Call(∂.LikeOrVal(Scope(7), Scope(2)):i8[]?), Call(∂.LikeOrVal(Scope(7), Scope(3)):i8[*]), Call(∂.LikeOrVal(Scope(7), Scope(4)):r8[*]), Call(∂.LikeOrVal(Scope(7), Scope(5)):i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*))
Func sig: (<ctx>:x, Vals:g*) to (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Values, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 1) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 2) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 3) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
*** Ctx ping count: 0
###
> Recs->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Recs->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
BndKind:Call, Type:(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*, Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(-1:i8):i8[]), [with:2] Ref<i8[]?>(Call(∂.Tensor.Fill(-1:i8):i8[])), [with:3] Call(∂.Tensor.Fill(-1:i8, 1:i8):i8[*]), [with:4] Call(∂.Tensor.Fill(-1:r8, 1:i8):r8[*]), [with:5] Call(∂.Tensor.Fill(-1:i8, 1:i8, 1:i8):i8[*,*]), Call(∂.ForEach([map:6] Global(Recs), Call(∂.Guard([guard:7] Scope(6), (Call(∂.LikeOrVal(Scope(7), str()):s), Call(∂.LikeOrVal(Scope(7), Scope(1)):i8[]), Call(∂.LikeOrVal(Scope(7), Scope(2)):i8[]?), Call(∂.LikeOrVal(Scope(7), Scope(3)):i8[*]), Call(∂.LikeOrVal(Scope(7), Scope(4)):r8[*]), Call(∂.LikeOrVal(Scope(7), Scope(5)):i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*))
Func sig: (<ctx>:x, Recs:g*) to (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Record, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 1) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 2) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 3) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 4) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 5) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
*** Ctx ping count: 0
###
> Tens->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1.0, 1)), it->L(TF(-1, 1, 1)))
Tens->(it->L(""), it->L(TF(-1)), it->L(TF(Opt(-1))), it->L(TF(-1, 1)), it->L(TF(-1, 1)), it->L(TF(-1, 1, 1))) : (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
BndKind:Call, Type:(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*, Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(-1:i8):i8[]), [with:2] Ref<i8[]?>(Call(∂.Tensor.Fill(-1:i8):i8[])), [with:3] Call(∂.Tensor.Fill(-1:i8, 1:i8):i8[*]), [with:4] Call(∂.Tensor.Fill(-1:r8, 1:i8):r8[*]), [with:5] Call(∂.Tensor.Fill(-1:i8, 1:i8, 1:i8):i8[*,*]), Call(∂.ForEach([map:6] Global(Tens), Call(∂.Guard([guard:7] Scope(6), (Call(∂.LikeOrVal(Scope(7), str()):s), Call(∂.LikeOrVal(Scope(7), Scope(1)):i8[]), Call(∂.LikeOrVal(Scope(7), Scope(2)):i8[]?), Call(∂.LikeOrVal(Scope(7), Scope(3)):i8[*]), Call(∂.LikeOrVal(Scope(7), Scope(4)):r8[*]), Call(∂.LikeOrVal(Scope(7), Scope(5)):i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*)):(s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*))
Func sig: (<ctx>:x, Tens:g*) to (s, i8[], i8[]?, i8[*], r8[*], i8[*,*])?*
Sequence: Seq<(str,Ten<i8>,Ten<i8>,Ten<i8>,Ten<r8>,Ten<i8>)>
 0) (Tensor, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 1) (, Ten<i8>()<> [1], Ten<i8>()<> [1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 2) (, Ten<i8>()<> [2], Ten<i8>()<> [2], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 3) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(3)<0> [3, 3, 3], Ten<r8>(1)<0> [-1], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 4) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(3)<0> [5.5, 5.5, 5.5], Ten<i8>(1,1)<0,0>
          [[-1]]
    )
 5) (, Ten<i8>()<> [-1], Ten<i8>()<> [-1], Ten<i8>(1)<0> [-1], Ten<r8>(1)<0> [-1], Ten<i8>(2,2)<0,0>
          [[4, 4]
           [4, 4]]
    )
*** Ctx ping count: 0
###
