**** New definitions: C, type: i8
**** New definitions: D, type: i8
**** New definitions: R, type: i8*
**** New definitions: S, type: i8*
**** New definitions: T, type: {N:i8, V:r8}*
**** New definitions: Sn, type: i8*
**** New definitions: Tn, type: {N:i8, V:r8}*

> Fold(x:S, y:1i8, x * y)
Fold(x : S, y : 1, x * y) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8))
Func sig: (<ctx>:x, S:i8*) to i8
Type: i8, Value: 3628800
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: 1, Mul(*1, %2))
###
> ScanX(x:S, y:1i8, x * y)
ScanX(x : S, y : 1, x * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.ScanX([map:1] Global(S), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8*))
Func sig: (S:i8*) to i8*
Sequence: Seq<i8>
 0) 1
 1) 1
 2) 2
 3) 6
 4) 24
 5) 120
 6) 720
 7) 5040
 8) 40320
 9) 362880
10) 3628800
###
> Generate(x: C + 1, y:1i8, (x max 1) * y)
Generate(x : C + 1, y : 1, (x max 1) * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Add(Global(C), 1:i8), [iter:2] 1:i8, Mul(Max(Scope(1), 1:i8), Scope(2))):i8*))
Func sig: (C:i8) to i8*
Sequence: Seq<i8>
 0) 1
 1) 1
 2) 2
 3) 6
 4) 24
 5) 120
 6) 720
 7) 5040
 8) 40320
 9) 362880
10) 3628800
###
> ScanZ(x:R, y:1i8, (x + 1) * y)
ScanZ(x : R, y : 1, (x + 1) * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.ScanZ([map:1] Global(R), [iter:2] 1:i8, Mul(Add(Scope(1), 1:i8), Scope(2))):i8*))
Func sig: (R:i8*) to i8*
Sequence: Seq<i8>
 0) 1
 1) 2
 2) 6
 3) 24
 4) 120
 5) 720
 6) 5040
 7) 40320
 8) 362880
 9) 3628800
###
> Generate(x:C, y:1i8, (x + 1) * y)
Generate(x : C, y : 1, (x + 1) * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] 1:i8, Mul(Add(Scope(1), 1:i8), Scope(2))):i8*))
Func sig: (C:i8) to i8*
Sequence: Seq<i8>
 0) 1
 1) 2
 2) 6
 3) 24
 4) 120
 5) 720
 6) 5040
 7) 40320
 8) 362880
 9) 3628800
###
> Fold(x:S, y:1ia, x * y)
Fold(x : S, y : 1, x * y) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] 1:i, Mul(Num<i>(Scope(1)), Scope(2))):i))
Func sig: (<ctx>:x, S:i8*) to i
Type: ia, Value: 3628800
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: 1, Mul(Num<i>(*1), %2))
###
> ScanX(x:S, y:1ia, x * y)
ScanX(x : S, y : 1, x * y) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanX([map:1] Global(S), [iter:2] 1:i, Mul(Num<i>(Scope(1)), Scope(2))):i*))
Func sig: (S:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 1
 2) 2
 3) 6
 4) 24
 5) 120
 6) 720
 7) 5040
 8) 40320
 9) 362880
10) 3628800
###
> Generate(x: C + 1, y:1ia, (x max 1) * y)
Generate(x : C + 1, y : 1, (x max 1) * y) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.Generate([rng:1] Add(Global(C), 1:i8), [iter:2] 1:i, Mul(Num<i>(Max(Scope(1), 1:i8)), Scope(2))):i*))
Func sig: (C:i8) to i*
Sequence: Seq<ia>
 0) 1
 1) 1
 2) 2
 3) 6
 4) 24
 5) 120
 6) 720
 7) 5040
 8) 40320
 9) 362880
10) 3628800
###
> ScanZ(x:R, y:1ia, (x + 1) * y)
ScanZ(x : R, y : 1, (x + 1) * y) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanZ([map:1] Global(R), [iter:2] 1:i, Mul(Num<i>(Add(Scope(1), 1:i8)), Scope(2))):i*))
Func sig: (R:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 6
 3) 24
 4) 120
 5) 720
 6) 5040
 7) 40320
 8) 362880
 9) 3628800
###
> Generate(x:C, y:1ia, (x + 1) * y)
Generate(x : C, y : 1, (x + 1) * y) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] 1:i, Mul(Num<i>(Add(Scope(1), 1:i8)), Scope(2))):i*))
Func sig: (C:i8) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 6
 3) 24
 4) 120
 5) 720
 6) 5040
 7) 40320
 8) 362880
 9) 3628800
###
> Fold(x:S, y:1r8, x * y)
Fold(x : S, y : 1, x * y) : r8
BndKind:Call, Type:r8, Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] 1:r8, Mul(Num<r8>(Scope(1)), Scope(2))):r8))
Func sig: (<ctx>:x, S:i8*) to r8
Type: r8, Value: 3628800
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: 1, Mul(Num<r8>(*1), %2))
###
> ScanX(x:S, y:1r8, x * y)
ScanX(x : S, y : 1, x * y) : r8*
BndKind:Call, Type:r8*, Bnd:(Call(∂.ScanX([map:1] Global(S), [iter:2] 1:r8, Mul(Num<r8>(Scope(1)), Scope(2))):r8*))
Func sig: (S:i8*) to r8*
Sequence: Seq<r8>
 0) 1
 1) 1
 2) 2
 3) 6
 4) 24
 5) 120
 6) 720
 7) 5040
 8) 40320
 9) 362880
10) 3628800
###
> Generate(x: C + 1, y:1r8, (x max 1) * y)
Generate(x : C + 1, y : 1, (x max 1) * y) : r8*
BndKind:Call, Type:r8*, Bnd:(Call(∂.Generate([rng:1] Add(Global(C), 1:i8), [iter:2] 1:r8, Mul(Num<r8>(Max(Scope(1), 1:i8)), Scope(2))):r8*))
Func sig: (C:i8) to r8*
Sequence: Seq<r8>
 0) 1
 1) 1
 2) 2
 3) 6
 4) 24
 5) 120
 6) 720
 7) 5040
 8) 40320
 9) 362880
10) 3628800
###
> ScanZ(x:R, y:1r8, (x + 1) * y)
ScanZ(x : R, y : 1, (x + 1) * y) : r8*
BndKind:Call, Type:r8*, Bnd:(Call(∂.ScanZ([map:1] Global(R), [iter:2] 1:r8, Mul(Num<r8>(Add(Scope(1), 1:i8)), Scope(2))):r8*))
Func sig: (R:i8*) to r8*
Sequence: Seq<r8>
 0) 1
 1) 2
 2) 6
 3) 24
 4) 120
 5) 720
 6) 5040
 7) 40320
 8) 362880
 9) 3628800
###
> Generate(x:C, y:1r8, (x + 1) * y)
Generate(x : C, y : 1, (x + 1) * y) : r8*
BndKind:Call, Type:r8*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] 1:r8, Mul(Num<r8>(Add(Scope(1), 1:i8)), Scope(2))):r8*))
Func sig: (C:i8) to r8*
Sequence: Seq<r8>
 0) 1
 1) 2
 2) 6
 3) 24
 4) 120
 5) 720
 6) 5040
 7) 40320
 8) 362880
 9) 3628800
###
> Fold(S, y:(0ia, 1ia), (y[1], y[0] + y[1]))
Fold(S, y : (0, 1), (y[1], y[0] + y[1])) : (i, i)
BndKind:Call, Type:(i, i), Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i)):(i, i)))
Func sig: (<ctx>:x, S:i8*) to (i, i)
Type: (ia,ia), Value: (55, 89)
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: (0, 1), (%2.1, Add(%2.0, %2.1)))
###
> Fold(S, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]))
Fold(S, y : (0, 0, 1), (#, y[2], y[1] + y[2])) : (i8, i, i)
BndKind:Call, Type:(i8, i, i), Bnd:(Call(∂.Fold([map:2] Global(S), [iter:3] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i)):(i8, i, i)))
Func sig: (<ctx>:x, S:i8*) to (i8, i, i)
Type: (i8,ia,ia), Value: (9, 55, 89)
*** Ctx ping count: 11
    [0](11): Fold(*2: S, %3: (0, 0, 1), (#1, %3.2, Add(%3.1, %3.2)))
###
> ScanX(S, y:(0ia, 1ia), (y[1], y[0] + y[1]))
ScanX(S, y : (0, 1), (y[1], y[0] + y[1])) : (i, i)*
BndKind:Call, Type:(i, i)*, Bnd:(Call(∂.ScanX([map:1] Global(S), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i)):(i, i)*))
Func sig: (S:i8*) to (i, i)*
Sequence: Seq<(ia,ia)>
 0) (0, 1)
 1) (1, 1)
 2) (1, 2)
 3) (2, 3)
 4) (3, 5)
 5) (5, 8)
 6) (8, 13)
 7) (13, 21)
 8) (21, 34)
 9) (34, 55)
10) (55, 89)
###
> ScanX(S, y:(-1, 0ia, 1ia), (#, y[2], y[1] + y[2]))
ScanX(S, y : (-1, 0, 1), (#, y[2], y[1] + y[2])) : (i8, i, i)*
BndKind:Call, Type:(i8, i, i)*, Bnd:(Call(∂.ScanX([map:2] Global(S), [iter:3] (-1:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i)):(i8, i, i)*))
Func sig: (S:i8*) to (i8, i, i)*
Sequence: Seq<(i8,ia,ia)>
 0) (-1, 0, 1)
 1) (0, 1, 1)
 2) (1, 1, 2)
 3) (2, 2, 3)
 4) (3, 3, 5)
 5) (4, 5, 8)
 6) (5, 8, 13)
 7) (6, 13, 21)
 8) (7, 21, 34)
 9) (8, 34, 55)
10) (9, 55, 89)
###
> ScanZ(R, y:(0ia, 1ia), (y[1], y[0] + y[1]))
ScanZ(R, y : (0, 1), (y[1], y[0] + y[1])) : (i, i)*
BndKind:Call, Type:(i, i)*, Bnd:(Call(∂.ScanZ([map:1] Global(R), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i)):(i, i)*))
Func sig: (R:i8*) to (i, i)*
Sequence: Seq<(ia,ia)>
 0) (1, 1)
 1) (1, 2)
 2) (2, 3)
 3) (3, 5)
 4) (5, 8)
 5) (8, 13)
 6) (13, 21)
 7) (21, 34)
 8) (34, 55)
 9) (55, 89)
###
> ScanZ(x:R, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]))
ScanZ(x : R, y : (0, 0, 1), (#, y[2], y[1] + y[2])) : (i8, i, i)*
BndKind:Call, Type:(i8, i, i)*, Bnd:(Call(∂.ScanZ([map:2] Global(R), [iter:3] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i)):(i8, i, i)*))
Func sig: (R:i8*) to (i8, i, i)*
Sequence: Seq<(i8,ia,ia)>
 0) (0, 1, 1)
 1) (1, 1, 2)
 2) (2, 2, 3)
 3) (3, 3, 5)
 4) (4, 5, 8)
 5) (5, 8, 13)
 6) (6, 13, 21)
 7) (7, 21, 34)
 8) (8, 34, 55)
 9) (9, 55, 89)
###
> Generate(C, y:(0ia, 1ia), (y[1], y[0] + y[1]))
Generate(C, y : (0, 1), (y[1], y[0] + y[1])) : (i, i)*
BndKind:Call, Type:(i, i)*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i)):(i, i)*))
Func sig: (C:i8) to (i, i)*
Sequence: Seq<(ia,ia)>
 0) (1, 1)
 1) (1, 2)
 2) (2, 3)
 3) (3, 5)
 4) (5, 8)
 5) (8, 13)
 6) (13, 21)
 7) (21, 34)
 8) (34, 55)
 9) (55, 89)
###
> Generate(C, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]))
Generate(C, y : (0, 0, 1), (#, y[2], y[1] + y[2])) : (i8, i, i)*
BndKind:Call, Type:(i8, i, i)*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(2), 2), Add(GetSlot(Scope(2), 1), GetSlot(Scope(2), 2))):(i8, i, i)):(i8, i, i)*))
Func sig: (C:i8) to (i8, i, i)*
Sequence: Seq<(i8,ia,ia)>
 0) (0, 1, 1)
 1) (1, 1, 2)
 2) (2, 2, 3)
 3) (3, 3, 5)
 4) (4, 5, 8)
 5) (5, 8, 13)
 6) (6, 13, 21)
 7) (7, 21, 34)
 8) (8, 34, 55)
 9) (9, 55, 89)
###
> Fold(S, y:(0ia, 1ia), (y[1], y[0] + y[1]))[1]
Fold(S, y : (0, 1), (y[1], y[0] + y[1]))[1] : i
BndKind:GetSlot, Type:i, Bnd:(GetSlot(Call(∂.Fold([map:1] Global(S), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i)):(i, i)), 1))
Func sig: (<ctx>:x, S:i8*) to i
Type: ia, Value: 89
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: (0, 1), (%2.1, Add(%2.0, %2.1)))
###
> Fold(S, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]))[2]
Fold(S, y : (0, 0, 1), (#, y[2], y[1] + y[2]))[2] : i
BndKind:GetSlot, Type:i, Bnd:(GetSlot(Call(∂.Fold([map:2] Global(S), [iter:3] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i)):(i8, i, i)), 2))
Func sig: (<ctx>:x, S:i8*) to i
Type: ia, Value: 89
*** Ctx ping count: 11
    [0](11): Fold(*2: S, %3: (0, 0, 1), (#1, %3.2, Add(%3.1, %3.2)))
###
> ScanX(S, y:(0ia, 1ia), (y[1], y[0] + y[1]))[1]
ScanX(S, y : (0, 1), (y[1], y[0] + y[1]))[1] : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanX([map:1] Global(S), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i*))
Func sig: (S:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 1
 2) 2
 3) 3
 4) 5
 5) 8
 6) 13
 7) 21
 8) 34
 9) 55
10) 89
###
> ScanX(S, y:(-1, 0ia, 1ia), (#, y[2], y[1] + y[2]))[2]
ScanX(S, y : (-1, 0, 1), (#, y[2], y[1] + y[2]))[2] : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanX([map:2] Global(S), [iter:3] (-1:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i), GetSlot(Scope(3), 2)):i*))
Func sig: (S:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 1
 2) 2
 3) 3
 4) 5
 5) 8
 6) 13
 7) 21
 8) 34
 9) 55
10) 89
###
> ScanZ(R, y:(0ia, 1ia), (y[1], y[0] + y[1]))[1]
ScanZ(R, y : (0, 1), (y[1], y[0] + y[1]))[1] : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanZ([map:1] Global(R), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i*))
Func sig: (R:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 3
 3) 5
 4) 8
 5) 13
 6) 21
 7) 34
 8) 55
 9) 89
###
> ScanZ(x:R, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]))[2]
ScanZ(x : R, y : (0, 0, 1), (#, y[2], y[1] + y[2]))[2] : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanZ([map:2] Global(R), [iter:3] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i), GetSlot(Scope(3), 2)):i*))
Func sig: (R:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 3
 3) 5
 4) 8
 5) 13
 6) 21
 7) 34
 8) 55
 9) 89
###
> Generate(C, y:(0ia, 1ia), (y[1], y[0] + y[1]))[1]
Generate(C, y : (0, 1), (y[1], y[0] + y[1]))[1] : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i*))
Func sig: (C:i8) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 3
 3) 5
 4) 8
 5) 13
 6) 21
 7) 34
 8) 55
 9) 89
###
> Generate(C, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]))[2]
Generate(C, y : (0, 0, 1), (#, y[2], y[1] + y[2]))[2] : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(2), 2), Add(GetSlot(Scope(2), 1), GetSlot(Scope(2), 2))):(i8, i, i), GetSlot(Scope(2), 2)):i*))
Func sig: (C:i8) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 3
 3) 5
 4) 8
 5) 13
 6) 21
 7) 34
 8) 55
 9) 89
###
> Fold(S, y:(0ia, 1ia), (y[1], y[0] + y[1]), y[1])
Fold(S, y : (0, 1), (y[1], y[0] + y[1]), y[1]) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i))
Func sig: (<ctx>:x, S:i8*) to i
Type: ia, Value: 89
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: (0, 1), (%2.1, Add(%2.0, %2.1)), %2.1)
###
> Fold(Range(1, 11), y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]), (y[0], y[2]))
Fold(Range(1, 11), y : (0, 0, 1), (#, y[2], y[1] + y[2]), (y[0], y[2])) : (i8, i)
BndKind:Call, Type:(i8, i), Bnd:(Call(∂.Fold([map:2] Call(∂.Range(1:i8, 11:i8):i8*), [iter:3] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i), (GetSlot(Scope(3), 0), GetSlot(Scope(3), 2)):(i8, i)):(i8, i)))
Func sig: (<ctx>:x) to (i8, i)
Type: (i8,ia), Value: (9, 89)
*** Ctx ping count: 11
    [0](11): Fold(*2: Range(1, 11), %3: (0, 0, 1), (#1, %3.2, Add(%3.1, %3.2)), (%3.0, %3.2))
###
> ScanX(S, y:(0ia, 1ia), (y[1], y[0] + y[1]), y[1])
ScanX(S, y : (0, 1), (y[1], y[0] + y[1]), y[1]) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanX([map:1] Global(S), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i*))
Func sig: (S:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 1
 2) 2
 3) 3
 4) 5
 5) 8
 6) 13
 7) 21
 8) 34
 9) 55
10) 89
###
> ScanX(S, y:(-1, 0ia, 1ia), (#, y[2], y[1] + y[2]), (y[0], y[2]))
ScanX(S, y : (-1, 0, 1), (#, y[2], y[1] + y[2]), (y[0], y[2])) : (i8, i)*
BndKind:Call, Type:(i8, i)*, Bnd:(Call(∂.ScanX([map:2] Global(S), [iter:3] (-1:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i), (GetSlot(Scope(3), 0), GetSlot(Scope(3), 2)):(i8, i)):(i8, i)*))
Func sig: (S:i8*) to (i8, i)*
Sequence: Seq<(i8,ia)>
 0) (-1, 1)
 1) (0, 1)
 2) (1, 2)
 3) (2, 3)
 4) (3, 5)
 5) (4, 8)
 6) (5, 13)
 7) (6, 21)
 8) (7, 34)
 9) (8, 55)
10) (9, 89)
###
> ScanZ(R, y:(0ia, 1ia), (y[1], y[0] + y[1]), y[1])
ScanZ(R, y : (0, 1), (y[1], y[0] + y[1]), y[1]) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanZ([map:1] Global(R), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i*))
Func sig: (R:i8*) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 3
 3) 5
 4) 8
 5) 13
 6) 21
 7) 34
 8) 55
 9) 89
###
> ScanZ(x:R, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]), (y[0], y[2]))
ScanZ(x : R, y : (0, 0, 1), (#, y[2], y[1] + y[2]), (y[0], y[2])) : (i8, i)*
BndKind:Call, Type:(i8, i)*, Bnd:(Call(∂.ScanZ([map:2] Global(R), [iter:3] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i), (GetSlot(Scope(3), 0), GetSlot(Scope(3), 2)):(i8, i)):(i8, i)*))
Func sig: (R:i8*) to (i8, i)*
Sequence: Seq<(i8,ia)>
 0) (0, 1)
 1) (1, 2)
 2) (2, 3)
 3) (3, 5)
 4) (4, 8)
 5) (5, 13)
 6) (6, 21)
 7) (7, 34)
 8) (8, 55)
 9) (9, 89)
###
> ScanZ(x:R, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]), (y[0], #, y[2]))
ScanZ(x : R, y : (0, 0, 1), (#, y[2], y[1] + y[2]), (y[0], #, y[2])) : (i8, i8, i)*
BndKind:Call, Type:(i8, i8, i)*, Bnd:(Call(∂.ScanZ([map:2] Global(R), [iter:3] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(3), 2), Add(GetSlot(Scope(3), 1), GetSlot(Scope(3), 2))):(i8, i, i), (GetSlot(Scope(3), 0), Scope(1), GetSlot(Scope(3), 2)):(i8, i8, i)):(i8, i8, i)*))
Func sig: (R:i8*) to (i8, i8, i)*
Sequence: Seq<(i8,i8,ia)>
 0) (0, 0, 1)
 1) (1, 1, 2)
 2) (2, 2, 3)
 3) (3, 3, 5)
 4) (4, 4, 8)
 5) (5, 5, 13)
 6) (6, 6, 21)
 7) (7, 7, 34)
 8) (8, 8, 55)
 9) (9, 9, 89)
###
> Generate(C, y:(0ia, 1ia), (y[1], y[0] + y[1]), y[1])
Generate(C, y : (0, 1), (y[1], y[0] + y[1]), y[1]) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i*))
Func sig: (C:i8) to i*
Sequence: Seq<ia>
 0) 1
 1) 2
 2) 3
 3) 5
 4) 8
 5) 13
 6) 21
 7) 34
 8) 55
 9) 89
###
> Generate(C, y:(0, 0ia, 1ia), (#, y[2], y[1] + y[2]), (y[0], #, y[2]))
Generate(C, y : (0, 0, 1), (#, y[2], y[1] + y[2]), (y[0], #, y[2])) : (i8, i8, i)*
BndKind:Call, Type:(i8, i8, i)*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] (0:i8, 0:i, 1:i):(i8, i, i), (Scope(1), GetSlot(Scope(2), 2), Add(GetSlot(Scope(2), 1), GetSlot(Scope(2), 2))):(i8, i, i), (GetSlot(Scope(2), 0), Scope(1), GetSlot(Scope(2), 2)):(i8, i8, i)):(i8, i8, i)*))
Func sig: (C:i8) to (i8, i8, i)*
Sequence: Seq<(i8,i8,ia)>
 0) (0, 0, 1)
 1) (1, 1, 2)
 2) (2, 2, 3)
 3) (3, 3, 5)
 4) (4, 4, 8)
 5) (5, 5, 13)
 6) (6, 6, 21)
 7) (7, 7, 34)
 8) (8, 8, 55)
 9) (9, 9, 89)
###
> Fold(S, y:(0i8, 0i8, 1i8), (y[1], y[2], 3 * y[0] + 2 * y[1] + 1 * y[2]))
Fold(S, y : (0, 0, 1), (y[1], y[2], 3 * y[0] + 2 * y[1] + 1 * y[2])) : (i8, i8, i8)
BndKind:Call, Type:(i8, i8, i8), Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] (0:i8, 0:i8, 1:i8):(i8, i8, i8), (GetSlot(Scope(2), 1), GetSlot(Scope(2), 2), Add(Mul(GetSlot(Scope(2), 0), 3:i8), Mul(GetSlot(Scope(2), 1), 2:i8), GetSlot(Scope(2), 2))):(i8, i8, i8)):(i8, i8, i8)))
Func sig: (<ctx>:x, S:i8*) to (i8, i8, i8)
Type: (i8,i8,i8), Value: (561, 1331, 3158)
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: (0, 0, 1), (%2.1, %2.2, Add(Mul(%2.0, 3), Mul(%2.1, 2), %2.2)))
###
> Fold(x:S, y:[], [x] ++ y)
Fold(x : S, y : [], [x] ++ y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] null:i8*, SeqConcat([Scope(1)]:i8*, Scope(2))):i8*))
Func sig: (<ctx>:x, S:i8*) to i8*
Sequence: Seq<i8>
 0) 10
 1) 9
 2) 8
 3) 7
 4) 6
 5) 5
 6) 4
 7) 3
 8) 2
 9) 1
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: null, SeqConcat([*1], %2))
###
> ScanX(x:S, y:0i8, x + y)
ScanX(x : S, y : 0, x + y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.ScanX([map:1] Global(S), [iter:2] 0:i8, Add(Scope(1), Scope(2))):i8*))
Func sig: (S:i8*) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 3
 3) 6
 4) 10
 5) 15
 6) 21
 7) 28
 8) 36
 9) 45
10) 55
###
> Fold(x:S, y:(0i8, []), (x + y[0], y[1] ++ [y[0]]))
Fold(x : S, y : (0, []), (x + y[0], y[1] ++ [y[0]])) : (i8, i8*)
BndKind:Call, Type:(i8, i8*), Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] (0:i8, null:i8*):(i8, i8*), (Add(Scope(1), GetSlot(Scope(2), 0)), SeqConcat(GetSlot(Scope(2), 1), [GetSlot(Scope(2), 0)]:i8*)):(i8, i8*)):(i8, i8*)))
Func sig: (<ctx>:x, S:i8*) to (i8, i8*)
Type: (i8,Seq<i8>), Value: (55, 
  Sequence: Seq<i8>
     0) 0
     1) 1
     2) 3
     3) 6
     4) 10
     5) 15
     6) 21
     7) 28
     8) 36
     9) 45
)
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: (0, null), (Add(*1, %2.0), SeqConcat(%2.1, [%2.0])))
###
> Fold(x:S, y:(0i8, []), (x + y[0], y[1] ++ [y[0]]), y[1] ++ [y[0]])
Fold(x : S, y : (0, []), (x + y[0], y[1] ++ [y[0]]), y[1] ++ [y[0]]) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Fold([map:1] Global(S), [iter:2] (0:i8, null:i8*):(i8, i8*), (Add(Scope(1), GetSlot(Scope(2), 0)), SeqConcat(GetSlot(Scope(2), 1), [GetSlot(Scope(2), 0)]:i8*)):(i8, i8*), SeqConcat(GetSlot(Scope(2), 1), [GetSlot(Scope(2), 0)]:i8*)):i8*))
Func sig: (<ctx>:x, S:i8*) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 3
 3) 6
 4) 10
 5) 15
 6) 21
 7) 28
 8) 36
 9) 45
10) 55
*** Ctx ping count: 11
    [0](11): Fold(*1: S, %2: (0, null), (Add(*1, %2.0), SeqConcat(%2.1, [%2.0])), SeqConcat(%2.1, [%2.0]))
###
> ScanZ(x:T, y:{ NS:0i8, VS:0r8, NP:1ia }, { NS: y.NS + x.N, VS: y.VS + x.V, NP: y.NP * x.N })
ScanZ(x : T, y : { NS : 0, VS : 0, NP : 1 }, { NS : y.NS + x.N, VS : y.VS + x.V, NP : y.NP * x.N }) : {NP:i, NS:i8, VS:r8}*
BndKind:Call, Type:{NP:i, NS:i8, VS:r8}*, Bnd:(Call(∂.ScanZ([map:1] Global(T), [iter:2] {NP:1:i, NS:0:i8, VS:0:r8}, {NP:Mul(GetField(Scope(2), NP), Num<i>(GetField(Scope(1), N))), NS:Add(GetField(Scope(2), NS), GetField(Scope(1), N)), VS:Add(GetField(Scope(2), VS), GetField(Scope(1), V))})))
Func sig: (T:{N:i8, V:r8}*) to {NP:i, NS:i8, VS:r8}*
Sequence: Seq<{ia,i8,r8}>
 0) { NP: 1, NS: 1, VS: 1 }
 1) { NP: 2, NS: 3, VS: 3 }
 2) { NP: 6, NS: 6, VS: 6 }
 3) { NP: 24, NS: 10, VS: 10 }
 4) { NP: 120, NS: 15, VS: 15 }
 5) { NP: 720, NS: 21, VS: 21 }
 6) { NP: 5040, NS: 28, VS: 28 }
 7) { NP: 40320, NS: 36, VS: 36 }
 8) { NP: 362880, NS: 45, VS: 45 }
 9) { NP: 3628800, NS: 55, VS: 55 }
###
> ScanZ(x:T, y:{ NS:0i8, VS:0r8, NP:1ia }, { NS: y.NS + x.N, VS: y.VS + x.V, NP: y.NP * x.N }, x & y)
ScanZ(x : T, y : { NS : 0, VS : 0, NP : 1 }, { NS : y.NS + x.N, VS : y.VS + x.V, NP : y.NP * x.N }, x & y) : {N:i8, NP:i, NS:i8, V:r8, VS:r8}*
BndKind:Call, Type:{N:i8, NP:i, NS:i8, V:r8, VS:r8}*, Bnd:(Call(∂.ScanZ([map:1] Global(T), [iter:2] {NP:1:i, NS:0:i8, VS:0:r8}, {NP:Mul(GetField(Scope(2), NP), Num<i>(GetField(Scope(1), N))), NS:Add(GetField(Scope(2), NS), GetField(Scope(1), N)), VS:Add(GetField(Scope(2), VS), GetField(Scope(1), V))}, RecordConcat(Scope(1), Scope(2)))))
Func sig: (T:{N:i8, V:r8}*) to {N:i8, NP:i, NS:i8, V:r8, VS:r8}*
Sequence: Seq<{i8,ia,i8,r8,r8}>
 0) { N: 1, NP: 1, NS: 1, V: 1, VS: 1 }
 1) { N: 2, NP: 2, NS: 3, V: 2, VS: 3 }
 2) { N: 3, NP: 6, NS: 6, V: 3, VS: 6 }
 3) { N: 4, NP: 24, NS: 10, V: 4, VS: 10 }
 4) { N: 5, NP: 120, NS: 15, V: 5, VS: 15 }
 5) { N: 6, NP: 720, NS: 21, V: 6, VS: 21 }
 6) { N: 7, NP: 5040, NS: 28, V: 7, VS: 28 }
 7) { N: 8, NP: 40320, NS: 36, V: 8, VS: 36 }
 8) { N: 9, NP: 362880, NS: 45, V: 9, VS: 45 }
 9) { N: 10, NP: 3628800, NS: 55, V: 10, VS: 55 }
###
> ForEach(x:R, x * x)
ForEach(x : R, x * x) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.ForEach([map:1] Global(R), Mul(Scope(1), Scope(1))):i8*))
Func sig: (R:i8*) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 4
 3) 9
 4) 16
 5) 25
 6) 36
 7) 49
 8) 64
 9) 81
###
> Generate(x:C, x * x)
Generate(x : C, x * x) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Global(C), Mul(Scope(1), Scope(1))):i8*))
Func sig: (C:i8) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 4
 3) 9
 4) 16
 5) 25
 6) 36
 7) 49
 8) 64
 9) 81
###
> Generate(x:C, x * #)
Generate(x : C, x * #) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Global(C), Mul(Scope(1), Scope(1))):i8*))
Func sig: (C:i8) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 4
 3) 9
 4) 16
 5) 25
 6) 36
 7) 49
 8) 64
 9) 81
###
> ForEach(x:R, x * (x + 1) / 2)
ForEach(x : R, x * (x + 1) / 2) : r8*
BndKind:Call, Type:r8*, Bnd:(Call(∂.ForEach([map:1] Global(R), Mul(Num<r8>(Mul(Scope(1), Add(Scope(1), 1:i8))), [/] 2:r8)):r8*))
Func sig: (R:i8*) to r8*
Sequence: Seq<r8>
 0) 0
 1) 1
 2) 3
 3) 6
 4) 10
 5) 15
 6) 21
 7) 28
 8) 36
 9) 45
###
> Generate(x:C, x * (x + 1) / 2)
Generate(x : C, x * (x + 1) / 2) : r8*
BndKind:Call, Type:r8*, Bnd:(Call(∂.Generate([rng:1] Global(C), Mul(Num<r8>(Mul(Scope(1), Add(Scope(1), 1:i8))), [/] 2:r8)):r8*))
Func sig: (C:i8) to r8*
Sequence: Seq<r8>
 0) 0
 1) 1
 2) 3
 3) 6
 4) 10
 5) 15
 6) 21
 7) 28
 8) 36
 9) 45
###
> Generate(x:C, x * (# + 1) / 2)
Generate(x : C, x * (# + 1) / 2) : r8*
BndKind:Call, Type:r8*, Bnd:(Call(∂.Generate([rng:1] Global(C), Mul(Num<r8>(Mul(Scope(1), Add(Scope(1), 1:i8))), [/] 2:r8)):r8*))
Func sig: (C:i8) to r8*
Sequence: Seq<r8>
 0) 0
 1) 1
 2) 3
 3) 6
 4) 10
 5) 15
 6) 21
 7) 28
 8) 36
 9) 45
###
> Fold(x:Sn, y:1i8, x * y)
Fold(x : Sn, y : 1, x * y) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Fold([map:1] Global(Sn), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8))
Func sig: (<ctx>:x, Sn:i8*) to i8
Type: i8, Value: 1
*** Ctx ping count: 0
###
> Fold(x:Sn, y:1i8, # * x * y)
Fold(x : Sn, y : 1, # * x * y) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Fold([map:2] Global(Sn), [iter:3] 1:i8, Mul(Scope(1), Scope(2), Scope(3))):i8))
Func sig: (<ctx>:x, Sn:i8*) to i8
Type: i8, Value: 1
*** Ctx ping count: 0
###
> Fold(x:Sn, y:1i8, # * x * y, 1000 + y)
Fold(x : Sn, y : 1, # * x * y, 1000 + y) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Fold([map:2] Global(Sn), [iter:3] 1:i8, Mul(Scope(1), Scope(2), Scope(3)), Add(Scope(3), 1000:i8)):i8))
Func sig: (<ctx>:x, Sn:i8*) to i8
Type: i8, Value: 1001
*** Ctx ping count: 0
###
> ScanX(x:Sn, y:1i8, x * y)
ScanX(x : Sn, y : 1, x * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.ScanX([map:1] Global(Sn), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8*))
Func sig: (Sn:i8*) to i8*
Sequence: Seq<i8>
 0) 1
###
> Fold(Sn, y:(0ia, 1ia), (y[1], y[0] + y[1]), y[1])
Fold(Sn, y : (0, 1), (y[1], y[0] + y[1]), y[1]) : i
BndKind:Call, Type:i, Bnd:(Call(∂.Fold([map:1] Global(Sn), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i))
Func sig: (<ctx>:x, Sn:i8*) to i
Type: ia, Value: 1
*** Ctx ping count: 0
###
> ScanX(Sn, y:(0ia, 1ia), (y[1], y[0] + y[1]), y[1])
ScanX(Sn, y : (0, 1), (y[1], y[0] + y[1]), y[1]) : i*
BndKind:Call, Type:i*, Bnd:(Call(∂.ScanX([map:1] Global(Sn), [iter:2] (0:i, 1:i):(i, i), (GetSlot(Scope(2), 1), Add(GetSlot(Scope(2), 0), GetSlot(Scope(2), 1))):(i, i), GetSlot(Scope(2), 1)):i*))
Func sig: (Sn:i8*) to i*
Sequence: Seq<ia>
 0) 1
###
> ScanZ(x:Tn, y:{ NS:0i8, VS:0r8, NP:1ia }, { NS: y.NS + x.N, VS: y.VS + x.V, NP: y.NP * x.N })
ScanZ(x : Tn, y : { NS : 0, VS : 0, NP : 1 }, { NS : y.NS + x.N, VS : y.VS + x.V, NP : y.NP * x.N }) : {NP:i, NS:i8, VS:r8}*
BndKind:Call, Type:{NP:i, NS:i8, VS:r8}*, Bnd:(Call(∂.ScanZ([map:1] Global(Tn), [iter:2] {NP:1:i, NS:0:i8, VS:0:r8}, {NP:Mul(GetField(Scope(2), NP), Num<i>(GetField(Scope(1), N))), NS:Add(GetField(Scope(2), NS), GetField(Scope(1), N)), VS:Add(GetField(Scope(2), VS), GetField(Scope(1), V))})))
Func sig: (Tn:{N:i8, V:r8}*) to {NP:i, NS:i8, VS:r8}*
Type: <null>, Value: <null>
###
> ScanZ(x:Tn, y:{ NS:0i8, VS:0r8, NP:1ia }, { NS: y.NS + x.N, VS: y.VS + x.V, NP: y.NP * x.N }, x & y)
ScanZ(x : Tn, y : { NS : 0, VS : 0, NP : 1 }, { NS : y.NS + x.N, VS : y.VS + x.V, NP : y.NP * x.N }, x & y) : {N:i8, NP:i, NS:i8, V:r8, VS:r8}*
BndKind:Call, Type:{N:i8, NP:i, NS:i8, V:r8, VS:r8}*, Bnd:(Call(∂.ScanZ([map:1] Global(Tn), [iter:2] {NP:1:i, NS:0:i8, VS:0:r8}, {NP:Mul(GetField(Scope(2), NP), Num<i>(GetField(Scope(1), N))), NS:Add(GetField(Scope(2), NS), GetField(Scope(1), N)), VS:Add(GetField(Scope(2), VS), GetField(Scope(1), V))}, RecordConcat(Scope(1), Scope(2)))))
Func sig: (Tn:{N:i8, V:r8}*) to {N:i8, NP:i, NS:i8, V:r8, VS:r8}*
Type: <null>, Value: <null>
###
> ScanZ(x:Tn, y:{ NS:0i8, VS:0r8, NP:1ia }, { I: #, NS: y.NS + x.N, VS: y.VS + x.V, NP: y.NP * x.N })
ScanZ(x : Tn, y : { NS : 0, VS : 0, NP : 1 }, { I : #, NS : y.NS + x.N, VS : y.VS + x.V, NP : y.NP * x.N }) : {I:i8?, NP:i, NS:i8, VS:r8}*
BndKind:Call, Type:{I:i8?, NP:i, NS:i8, VS:r8}*, Bnd:(Call(∂.ScanZ([map:2] Global(Tn), [iter:3] {NP:1:i, NS:0:i8, VS:0:r8[, I:null:i8?]}, Ref<{I:i8?, NP:i, NS:i8, VS:r8}>({I:Scope(1), NP:Mul(GetField(Scope(3), NP), Num<i>(GetField(Scope(2), N))), NS:Add(GetField(Scope(3), NS), GetField(Scope(2), N)), VS:Add(GetField(Scope(3), VS), GetField(Scope(2), V))}))))
Func sig: (Tn:{N:i8, V:r8}*) to {I:i8?, NP:i, NS:i8, VS:r8}*
Type: <null>, Value: <null>
###
> ScanZ(x:Tn, y:{ NS:0i8, VS:0r8, NP:1ia }, { I: #, NS: y.NS + x.N, VS: y.VS + x.V, NP: y.NP * x.N }, (x & y))
ScanZ(x : Tn, y : { NS : 0, VS : 0, NP : 1 }, { I : #, NS : y.NS + x.N, VS : y.VS + x.V, NP : y.NP * x.N }, x & y) : {I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8}*
BndKind:Call, Type:{I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8}*, Bnd:(Call(∂.ScanZ([map:2] Global(Tn), [iter:3] {NP:1:i, NS:0:i8, VS:0:r8[, I:null:i8?]}, Ref<{I:i8?, NP:i, NS:i8, VS:r8}>({I:Scope(1), NP:Mul(GetField(Scope(3), NP), Num<i>(GetField(Scope(2), N))), NS:Add(GetField(Scope(3), NS), GetField(Scope(2), N)), VS:Add(GetField(Scope(3), VS), GetField(Scope(2), V))}), RecordConcat(Scope(2), Scope(3)))))
Func sig: (Tn:{N:i8, V:r8}*) to {I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8}*
Type: <null>, Value: <null>
###
> ScanZ(x:Tn, y:{ NS:0i8, VS:0r8, NP:1ia }, { I: #, NS: y.NS + x.N, VS: y.VS + x.V, NP: y.NP * x.N }, (#, x & y))
ScanZ(x : Tn, y : { NS : 0, VS : 0, NP : 1 }, { I : #, NS : y.NS + x.N, VS : y.VS + x.V, NP : y.NP * x.N }, (#, x & y)) : (i8, {I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8})*
BndKind:Call, Type:(i8, {I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8})*, Bnd:(Call(∂.ScanZ([map:2] Global(Tn), [iter:3] {NP:1:i, NS:0:i8, VS:0:r8[, I:null:i8?]}, Ref<{I:i8?, NP:i, NS:i8, VS:r8}>({I:Scope(1), NP:Mul(GetField(Scope(3), NP), Num<i>(GetField(Scope(2), N))), NS:Add(GetField(Scope(3), NS), GetField(Scope(2), N)), VS:Add(GetField(Scope(3), VS), GetField(Scope(2), V))}), (Scope(1), RecordConcat(Scope(2), Scope(3))):(i8, {I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8})):(i8, {I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8})*))
Func sig: (Tn:{N:i8, V:r8}*) to (i8, {I:i8?, N:i8, NP:i, NS:i8, V:r8, VS:r8})*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(0), x * x)
Generate(x : Wrap(0), x * x) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(0:i8):i8), Mul(Scope(1), Scope(1))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(0), x * #)
Generate(x : Wrap(0), x * #) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(0:i8):i8), Mul(Scope(1), Scope(1))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(0), y:1i8, x * y)
Generate(x : Wrap(0), y : 1, x * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(0:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(0), y:1i8, # * y)
Generate(x : Wrap(0), y : 1, # * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(0:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(0), y:1i8, x * y, it + 1)
Generate(x : Wrap(0), y : 1, x * y, it + 1) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(0:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2)), Add(Scope(2), 1:i8)):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(0), y:1i8, # * y, it + 1)
Generate(x : Wrap(0), y : 1, # * y, it + 1) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(0:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2)), Add(Scope(2), 1:i8)):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(0), y:1i8, # * y, (#, it + 1))
Generate(x : Wrap(0), y : 1, # * y, (#, it + 1)) : (i8, i8)*
BndKind:Call, Type:(i8, i8)*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(0:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2)), (Scope(1), Add(Scope(2), 1:i8)):(i8, i8)):(i8, i8)*))
Func sig: () to (i8, i8)*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(-1), x * x)
Generate(x : Wrap(-1), x * x) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(-1:i8):i8), Mul(Scope(1), Scope(1))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(-1), x * #)
Generate(x : Wrap(-1), x * #) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(-1:i8):i8), Mul(Scope(1), Scope(1))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(-1), y:1i8, x * y)
Generate(x : Wrap(-1), y : 1, x * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(-1:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(-1), y:1i8, # * y)
Generate(x : Wrap(-1), y : 1, # * y) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(-1:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2))):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(-1), y:1i8, x * y, it + 1)
Generate(x : Wrap(-1), y : 1, x * y, it + 1) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(-1:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2)), Add(Scope(2), 1:i8)):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(-1), y:1i8, # * y, it + 1)
Generate(x : Wrap(-1), y : 1, # * y, it + 1) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(-1:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2)), Add(Scope(2), 1:i8)):i8*))
Func sig: () to i8*
Type: <null>, Value: <null>
###
> Generate(x:Wrap(-1), y:1i8, # * y, (#, it + 1))
Generate(x : Wrap(-1), y : 1, # * y, (#, it + 1)) : (i8, i8)*
BndKind:Call, Type:(i8, i8)*, Bnd:(Call(∂.Generate([rng:1] Call(∂.Test.Wrap(-1:i8):i8), [iter:2] 1:i8, Mul(Scope(1), Scope(2)), (Scope(1), Add(Scope(2), 1:i8)):(i8, i8)):(i8, i8)*))
Func sig: () to (i8, i8)*
Type: <null>, Value: <null>
###
> Generate(x:C, (x, #))
Generate(x : C, (x, #)) : (i8, i8)*
BndKind:Call, Type:(i8, i8)*, Bnd:(Call(∂.Generate([rng:1] Global(C), (Scope(1), Scope(1)):(i8, i8)):(i8, i8)*))
Func sig: (C:i8) to (i8, i8)*
Sequence: Seq<(i8,i8)>
 0) (0, 0)
 1) (1, 1)
 2) (2, 2)
 3) (3, 3)
 4) (4, 4)
 5) (5, 5)
 6) (6, 6)
 7) (7, 7)
 8) (8, 8)
 9) (9, 9)
###
> Fold(x:S, y:0, y + #)
Fold(x : S, y : 0, y + #) : i8
BndKind:Call, Type:i8, Bnd:(Call(∂.Fold([map:2] Global(S), [iter:3] 0:i8, Add(Scope(3), Scope(1))):i8))
Func sig: (<ctx>:x, S:i8*) to i8
Type: i8, Value: 45
*** Ctx ping count: 11
    [0](11): Fold(*2: S, %3: 0, Add(%3, #1))
###
> ScanX(x:S, y:0, y + #)
ScanX(x : S, y : 0, y + #) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.ScanX([map:2] Global(S), [iter:3] 0:i8, Add(Scope(3), Scope(1))):i8*))
Func sig: (S:i8*) to i8*
Sequence: Seq<i8>
 0) 0
 1) 0
 2) 1
 3) 3
 4) 6
 5) 10
 6) 15
 7) 21
 8) 28
 9) 36
10) 45
###
> ScanZ(x:S, y:0, y + #)
ScanZ(x : S, y : 0, y + #) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.ScanZ([map:2] Global(S), [iter:3] 0:i8, Add(Scope(3), Scope(1))):i8*))
Func sig: (S:i8*) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 3
 3) 6
 4) 10
 5) 15
 6) 21
 7) 28
 8) 36
 9) 45
###
> Generate(x:C, y:0, y + #)
Generate(x : C, y : 0, y + #) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] 0:i8, Add(Scope(2), Scope(1))):i8*))
Func sig: (C:i8) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 3
 3) 6
 4) 10
 5) 15
 6) 21
 7) 28
 8) 36
 9) 45
###
> ScanZ(x:S, y:0, y + #, (#, y))
ScanZ(x : S, y : 0, y + #, (#, y)) : (i8, i8)*
BndKind:Call, Type:(i8, i8)*, Bnd:(Call(∂.ScanZ([map:2] Global(S), [iter:3] 0:i8, Add(Scope(3), Scope(1)), (Scope(1), Scope(3)):(i8, i8)):(i8, i8)*))
Func sig: (S:i8*) to (i8, i8)*
Sequence: Seq<(i8,i8)>
 0) (0, 0)
 1) (1, 1)
 2) (2, 3)
 3) (3, 6)
 4) (4, 10)
 5) (5, 15)
 6) (6, 21)
 7) (7, 28)
 8) (8, 36)
 9) (9, 45)
###
> Generate(x:C, y:0, y + #, (#, y))
Generate(x : C, y : 0, y + #, (#, y)) : (i8, i8)*
BndKind:Call, Type:(i8, i8)*, Bnd:(Call(∂.Generate([rng:1] Global(C), [iter:2] 0:i8, Add(Scope(2), Scope(1)), (Scope(1), Scope(2)):(i8, i8)):(i8, i8)*))
Func sig: (C:i8) to (i8, i8)*
Sequence: Seq<(i8,i8)>
 0) (0, 0)
 1) (1, 1)
 2) (2, 3)
 3) (3, 6)
 4) (4, 10)
 5) (5, 15)
 6) (6, 21)
 7) (7, 28)
 8) (8, 36)
 9) (9, 45)
###
> Generate(5, it + (C if it mod 2 = 0 else D)) // Root range scope curries globals.
Generate(5, it + (C if it mod 2 @= 0 else D)) : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Generate([rng:1] 5:i8, Add(Scope(1), If(Cmp(IntMod(Scope(1), 2:i8) @= 0:i8), Global(C), Global(D)))):i8*))
Func sig: (C:i8, D:i8) to i8*
Sequence: Seq<i8>
 0) 10
 1) 2001
 2) 12
 3) 2003
 4) 14
###
