> 7r4->Tensor.Fill()
7->Tensor.Fill() : r4[]
BndKind:Call, Type:r4[], Bnd:(Call(∂.Tensor.Fill(7:r4):r4[]))
Func sig: () to r4[]
Ten<r4>()<> [7]
###
> 7r4->Tensor.Fill(2)
7->Tensor.Fill(2) : r4[*]
BndKind:Call, Type:r4[*], Bnd:(Call(∂.Tensor.Fill(7:r4, 2:i8):r4[*]))
Func sig: (<ctx>:x) to r4[*]
Ten<r4>(2)<0> [7, 7]
*** Ctx ping count: 0
###
> 3r4->Tensor.Fill(2, 4)
3->Tensor.Fill(2, 4) : r4[*,*]
BndKind:Call, Type:r4[*,*], Bnd:(Call(∂.Tensor.Fill(3:r4, 2:i8, 4:i8):r4[*,*]))
Func sig: (<ctx>:x) to r4[*,*]
Ten<r4>(2,4)<0,0>
  [[3, 3, 3, 3]
   [3, 3, 3, 3]]
*** Ctx ping count: 0
###
> 3r4->Tensor.Fill(2, 4, 3)
3->Tensor.Fill(2, 4, 3) : r4[*,*,*]
BndKind:Call, Type:r4[*,*,*], Bnd:(Call(∂.Tensor.Fill(3:r4, 2:i8, 4:i8, 3:i8):r4[*,*,*]))
Func sig: (<ctx>:x) to r4[*,*,*]
Ten<r4>(2,4,3)<0,0,0>
  [[[3, 3, 3]
    [3, 3, 3]
    [3, 3, 3]
    [3, 3, 3]]

   [[3, 3, 3]
    [3, 3, 3]
    [3, 3, 3]
    [3, 3, 3]]]
*** Ctx ping count: 0
###
> 3r4->Tensor.Fill(2, 4, 3, 2)
3->Tensor.Fill(2, 4, 3, 2) : r4[*,*,*,*]
BndKind:Call, Type:r4[*,*,*,*], Bnd:(Call(∂.Tensor.Fill(3:r4, 2:i8, 4:i8, 3:i8, 2:i8):r4[*,*,*,*]))
Func sig: (<ctx>:x) to r4[*,*,*,*]
Ten<r4>(2,4,3,2)<0,0,0,0>
  [[[[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]]


   [[[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]]]
*** Ctx ping count: 0
###
> 3r4->Tensor.Fill(Wrap(2), Wrap(4), Wrap(3), Wrap(2))
3->Tensor.Fill(Wrap(2), Wrap(4), Wrap(3), Wrap(2)) : r4[*,*,*,*]
BndKind:Call, Type:r4[*,*,*,*], Bnd:(Call(∂.Tensor.Fill(3:r4, Call(∂.Test.Wrap(2:i8):i8), Call(∂.Test.Wrap(4:i8):i8), Call(∂.Test.Wrap(3:i8):i8), Call(∂.Test.Wrap(2:i8):i8)):r4[*,*,*,*]))
Func sig: (<ctx>:x) to r4[*,*,*,*]
Ten<r4>(2,4,3,2)<0,0,0,0>
  [[[[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]]


   [[[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]

    [[3, 3]
     [3, 3]
     [3, 3]]]]
*** Ctx ping count: 0
###
> null->Tensor.From()
null->Tensor.From() : o[*]
BndKind:Tensor, Type:o[*], Bnd:([!  !]:o[0])
Func sig: () to o[*]
Ten<obj>(0)<0> []
###
> null->Tensor.From(5)
null->Tensor.From(5) : o[*]
BndKind:Call, Type:o[*], Bnd:(Call(∂.Tensor.From(null:o*, 5:i8):o[*]))
Func sig: (<ctx>:x) to o[*]
Ten<obj>(5)<0> [<null>, <null>, <null>, <null>, <null>]
*** Ctx ping count: 0
###
> [1, 2, 3]->Tensor.From()
[1, 2, 3]->Tensor.From() : i8[*]
BndKind:Tensor, Type:i8[*], Bnd:([! 1:i8, 2:i8, 3:i8 !]:i8[3])
Func sig: () to i8[*]
Ten<i8>(3)<1> [1, 2, 3]
###
> Range(12)->Tensor.From()
Range(12)->Tensor.From() : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*)):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(0)
Range(12)->Tensor.From(0) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 0:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(0)<0> []
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(5)
Range(12)->Tensor.From(5) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 5:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(5)<1> [0, 1, 2, 3, 4]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)
Range(12)->Tensor.From(4, 3) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*]))
Func sig: (<ctx>:x) to i8[*,*]
Ten<i8>(4,3)<3,1>
  [[0, 1, 2]
   [3, 4, 5]
   [6, 7, 8]
   [9, 10, 11]]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(2, 3, 2)
Range(12)->Tensor.From(2, 3, 2) : i8[*,*,*]
BndKind:Call, Type:i8[*,*,*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 2:i8):i8[*,*,*]))
Func sig: (<ctx>:x) to i8[*,*,*]
Ten<i8>(2,3,2)<6,2,1>
  [[[0, 1]
    [2, 3]
    [4, 5]]

   [[6, 7]
    [8, 9]
    [10, 11]]]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(2, 3, 4)
Range(12)->Tensor.From(2, 3, 4) : i8[*,*,*]
BndKind:Call, Type:i8[*,*,*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 4:i8):i8[*,*,*]))
Func sig: (<ctx>:x) to i8[*,*,*]
Ten<i8>(2,3,4)<12,4,1>
  [[[0, 1, 2, 3]
    [4, 5, 6, 7]
    [8, 9, 10, 11]]

   [[0, 0, 0, 0]
    [0, 0, 0, 0]
    [0, 0, 0, 0]]]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(Wrap(2), Wrap(3), Wrap(4))
Range(12)->Tensor.From(Wrap(2), Wrap(3), Wrap(4)) : i8[*,*,*]
BndKind:Call, Type:i8[*,*,*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), Call(∂.Test.Wrap(2:i8):i8), Call(∂.Test.Wrap(3:i8):i8), Call(∂.Test.Wrap(4:i8):i8)):i8[*,*,*]))
Func sig: (<ctx>:x) to i8[*,*,*]
Ten<i8>(2,3,4)<12,4,1>
  [[[0, 1, 2, 3]
    [4, 5, 6, 7]
    [8, 9, 10, 11]]

   [[0, 0, 0, 0]
    [0, 0, 0, 0]
    [0, 0, 0, 0]]]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(Wrap(-1), Wrap(-3))
Range(12)->Tensor.From(Wrap(-1), Wrap(-3)) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), Call(∂.Test.Wrap(-1:i8):i8), Call(∂.Test.Wrap(-3:i8):i8)):i8[*,*]))
Func sig: (<ctx>:x) to i8[*,*]
Ten<i8>(0,0)<0,0> []
*** Ctx ping count: 0
###
> Range(12)->Null()->Tensor.From(3)
Range(12)->Null()->Tensor.From(3) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.From(null:i8*, 3:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(3)<0> [0, 0, 0]
*** Ctx ping count: 0
###
> Range(12)->Null()->Tensor.From(3, 4)
Range(12)->Null()->Tensor.From(3, 4) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.From(null:i8*, 3:i8, 4:i8):i8[*,*]))
Func sig: (<ctx>:x) to i8[*,*]
Ten<i8>(3,4)<0,0>
  [[0, 0, 0, 0]
   [0, 0, 0, 0]
   [0, 0, 0, 0]]
*** Ctx ping count: 0
###
> Range(12)->CastR4()->Tensor.From(4, 3)
Range(12)->CastR4()->Tensor.From(4, 3) : r4[*,*]
BndKind:Call, Type:r4[*,*], Bnd:(Call(∂.Tensor.From(Call(∂.ForEach([map:1] Call(∂.Range(12:i8):i8*), Num<r4>(Scope(1))):r4*), 4:i8, 3:i8):r4[*,*]))
Func sig: (<ctx>:x) to r4[*,*]
Ten<r4>(4,3)<3,1>
  [[0, 1, 2]
   [3, 4, 5]
   [6, 7, 8]
   [9, 10, 11]]
*** Ctx ping count: 0
###
> Range(12)->TakeIf(it mod 3 != 0)->CastU1()->Tensor.From(4, 2)
Range(12)->TakeIf(it mod 3 !@= 0)->CastU1()->Tensor.From(4, 2) : u1[*,*]
BndKind:Call, Type:u1[*,*], Bnd:(Call(∂.Tensor.From(Call(∂.ForEach([map:2] Call(∂.Take([map:1] Call(∂.Range(12:i8):i8*), [if] Cmp(IntMod(Scope(1), 3:i8) !@= 0:i8)):i8*), Call(∂.CastU1(Scope(2)):u1)):u1*), 4:i8, 2:i8):u1[*,*]))
Func sig: (<ctx>:x) to u1[*,*]
Ten<u1>(4,2)<2,1>
  [[1, 2]
   [4, 5]
   [7, 8]
   [10, 11]]
*** Ctx ping count: 4
    [0](4): Take(*1: Range(12), [if] IntMod(*1, 3) !@= 0)
###
> Range(12)->TakeIf(it mod 3 != 0)->CastU1()->Tensor.From(4, 3)
Range(12)->TakeIf(it mod 3 !@= 0)->CastU1()->Tensor.From(4, 3) : u1[*,*]
BndKind:Call, Type:u1[*,*], Bnd:(Call(∂.Tensor.From(Call(∂.ForEach([map:2] Call(∂.Take([map:1] Call(∂.Range(12:i8):i8*), [if] Cmp(IntMod(Scope(1), 3:i8) !@= 0:i8)):i8*), Call(∂.CastU1(Scope(2)):u1)):u1*), 4:i8, 3:i8):u1[*,*]))
Func sig: (<ctx>:x) to u1[*,*]
Ten<u1>(4,3)<3,1>
  [[1, 2, 4]
   [5, 7, 8]
   [10, 11, 0]
   [0, 0, 0]]
*** Ctx ping count: 4
    [0](4): Take(*1: Range(12), [if] IntMod(*1, 3) !@= 0)
###
> Range(1, 5)->{A: it, B:ToText(it), C:{X:it}, D:(it,)}->Tensor.From()
Range(1, 5)->{ A : it, B : ToText(it), C : { X : it }, D : (it,) }->Tensor.From() : {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*], Bnd:(Call(∂.Tensor.From(Call(∂.ForEach([map:1] Call(∂.Range(1:i8, 5:i8):i8*), {A:Scope(1), B:Call(∂.ToText(Scope(1)):s), C:{X:Scope(1)}, D:(Scope(1),):(i8)}))):{A:i8, B:s, C:{X:i8}, D:(i8)}[*]))
Func sig: (<ctx>:x) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
Ten<{i8,str,{i8},(i8)}>(4)<1> [{ A: 1, B: 1, C: { X: 1 }, D: (1,) }, { A: 2, B: 2, C: { X: 2 }, D: (2,) }, { A: 3, B: 3, C: { X: 3 }, D: (3,) }, { A: 4, B: 4, C: { X: 4 }, D: (4,) }]
*** Ctx ping count: 0
###
> Range(1, 5)->Filter(false)->{A: it, B:ToText(it), C:{X:it}, D:(it,)}->Tensor.From()
Range(1, 5)->Filter(false)->{ A : it, B : ToText(it), C : { X : it }, D : (it,) }->Tensor.From() : {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
BndKind:Tensor, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*], Bnd:([!  !]:{A:i8, B:s, C:{X:i8}, D:(i8)}[0])
Func sig: () to {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
Ten<{i8,str,{i8},(i8)}>(0)<0> []
###
> Range(1, 5)->{A: it, B:ToText(it), C:{X:it}, D:(it,)}->Tensor.From(7)
Range(1, 5)->{ A : it, B : ToText(it), C : { X : it }, D : (it,) }->Tensor.From(7) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*], Bnd:(Call(∂.Tensor.From(Call(∂.ForEach([map:1] Call(∂.Range(1:i8, 5:i8):i8*), {A:Scope(1), B:Call(∂.ToText(Scope(1)):s), C:{X:Scope(1)}, D:(Scope(1),):(i8)})), 7:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*]))
Func sig: (<ctx>:x) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
Ten<{i8,str,{i8},(i8)}>(7)<1> [{ A: 1, B: 1, C: { X: 1 }, D: (1,) }, { A: 2, B: 2, C: { X: 2 }, D: (2,) }, { A: 3, B: 3, C: { X: 3 }, D: (3,) }, { A: 4, B: 4, C: { X: 4 }, D: (4,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
*** Ctx ping count: 0
###
> Range(1, 5)->{A: it, B:ToText(it), C:{X:it}, D:(it,)}->Tensor.From(2, 5)
Range(1, 5)->{ A : it, B : ToText(it), C : { X : it }, D : (it,) }->Tensor.From(2, 5) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*], Bnd:(Call(∂.Tensor.From(Call(∂.ForEach([map:1] Call(∂.Range(1:i8, 5:i8):i8*), {A:Scope(1), B:Call(∂.ToText(Scope(1)):s), C:{X:Scope(1)}, D:(Scope(1),):(i8)})), 2:i8, 5:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]))
Func sig: (<ctx>:x) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
Ten<{i8,str,{i8},(i8)}>(2,5)<5,1>
  [[{ A: 1, B: 1, C: { X: 1 }, D: (1,) }, { A: 2, B: 2, C: { X: 2 }, D: (2,) }, { A: 3, B: 3, C: { X: 3 }, D: (3,) }, { A: 4, B: 4, C: { X: 4 }, D: (4,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
   [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]
*** Ctx ping count: 0
###
> Range(1, 5)->{A: it, B:ToText(it), C:{X:it}, D:(it,)}->Tensor.From(3, 3, 3)
Range(1, 5)->{ A : it, B : ToText(it), C : { X : it }, D : (it,) }->Tensor.From(3, 3, 3) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*], Bnd:(Call(∂.Tensor.From(Call(∂.ForEach([map:1] Call(∂.Range(1:i8, 5:i8):i8*), {A:Scope(1), B:Call(∂.ToText(Scope(1)):s), C:{X:Scope(1)}, D:(Scope(1),):(i8)})), 3:i8, 3:i8, 3:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*]))
Func sig: (<ctx>:x) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*]
Ten<{i8,str,{i8},(i8)}>(3,3,3)<9,3,1>
  [[[{ A: 1, B: 1, C: { X: 1 }, D: (1,) }, { A: 2, B: 2, C: { X: 2 }, D: (2,) }, { A: 3, B: 3, C: { X: 3 }, D: (3,) }]
    [{ A: 4, B: 4, C: { X: 4 }, D: (4,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]

   [[{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]

   [[{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]]
*** Ctx ping count: 0
###
> Range(1, 5)->Filter(false)->{A: it, B:ToText(it), C:{X:it}, D:(it,)}->Tensor.From()->Reshape()
Range(1, 5)->Filter(false)->{ A : it, B : ToText(it), C : { X : it }, D : (it,) }->Tensor.From()->Reshape() : {A:i8, B:s, C:{X:i8}, D:(i8)}[]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[], Bnd:(Call(∂.Tensor.Reshape([!  !]:{A:i8, B:s, C:{X:i8}, D:(i8)}[0]):{A:i8, B:s, C:{X:i8}, D:(i8)}[]))
Func sig: (<ctx>:x) to {A:i8, B:s, C:{X:i8}, D:(i8)}[]
Ten<{i8,str,{i8},(i8)}>()<> [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
*** Ctx ping count: 0
###
> Range(1, 5)->Filter(false)->{A: it, B:ToText(it), C:{X:it}, D:(it,)}->Tensor.From()->Reshape(3, 0)
Range(1, 5)->Filter(false)->{ A : it, B : ToText(it), C : { X : it }, D : (it,) }->Tensor.From()->Reshape(3, 0) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*], Bnd:(Call(∂.Tensor.Reshape([!  !]:{A:i8, B:s, C:{X:i8}, D:(i8)}[0], 3:i8, 0:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]))
Func sig: (<ctx>:x) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
Ten<{i8,str,{i8},(i8)}>(3,0)<0,0> []
*** Ctx ping count: 0
###

**** New definitions: T, type: {A:i8, B:s, C:{X:i8}, D:(i8)}[*]

> T->Reshape()
T->Reshape() : {A:i8, B:s, C:{X:i8}, D:(i8)}[]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[], Bnd:(Call(∂.Tensor.Reshape(Global(T)):{A:i8, B:s, C:{X:i8}, D:(i8)}[]))
Func sig: (<ctx>:x, T:{A:i8, B:s, C:{X:i8}, D:(i8)}[*]) to {A:i8, B:s, C:{X:i8}, D:(i8)}[]
Ten<{i8,str,{i8},(i8)}>()<> [{ A: 1, B: 1, C: { X: 1 }, D: (1,) }]
*** Ctx ping count: 0
###
> T->Reshape(7)
T->Reshape(7) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*], Bnd:(Call(∂.Tensor.Reshape(Global(T), 7:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*]))
Func sig: (<ctx>:x, T:{A:i8, B:s, C:{X:i8}, D:(i8)}[*]) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*]
Ten<{i8,str,{i8},(i8)}>(7)<1> [{ A: 1, B: 1, C: { X: 1 }, D: (1,) }, { A: 2, B: 2, C: { X: 2 }, D: (2,) }, { A: 3, B: 3, C: { X: 3 }, D: (3,) }, { A: 4, B: 4, C: { X: 4 }, D: (4,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
*** Ctx ping count: 0
###
> T->Reshape(2, 5)
T->Reshape(2, 5) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*], Bnd:(Call(∂.Tensor.Reshape(Global(T), 2:i8, 5:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]))
Func sig: (<ctx>:x, T:{A:i8, B:s, C:{X:i8}, D:(i8)}[*]) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
Ten<{i8,str,{i8},(i8)}>(2,5)<5,1>
  [[{ A: 1, B: 1, C: { X: 1 }, D: (1,) }, { A: 2, B: 2, C: { X: 2 }, D: (2,) }, { A: 3, B: 3, C: { X: 3 }, D: (3,) }, { A: 4, B: 4, C: { X: 4 }, D: (4,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
   [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]
*** Ctx ping count: 0
###
> T->Reshape(3, 3, 3)
T->Reshape(3, 3, 3) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*], Bnd:(Call(∂.Tensor.Reshape(Global(T), 3:i8, 3:i8, 3:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*]))
Func sig: (<ctx>:x, T:{A:i8, B:s, C:{X:i8}, D:(i8)}[*]) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*,*]
Ten<{i8,str,{i8},(i8)}>(3,3,3)<9,3,1>
  [[[{ A: 1, B: 1, C: { X: 1 }, D: (1,) }, { A: 2, B: 2, C: { X: 2 }, D: (2,) }, { A: 3, B: 3, C: { X: 3 }, D: (3,) }]
    [{ A: 4, B: 4, C: { X: 4 }, D: (4,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]

   [[{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]

   [[{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]
    [{ A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }, { A: 0, B: <null>, C: { X: 0 }, D: (0,) }]]]
*** Ctx ping count: 0
###
> T->Reshape(4, 0)
T->Reshape(4, 0) : {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*], Bnd:(Call(∂.Tensor.Reshape(Global(T), 4:i8, 0:i8):{A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]))
Func sig: (<ctx>:x, T:{A:i8, B:s, C:{X:i8}, D:(i8)}[*]) to {A:i8, B:s, C:{X:i8}, D:(i8)}[*,*]
Ten<{i8,str,{i8},(i8)}>(4,0)<0,0> []
*** Ctx ping count: 0
###
> Tensor.From([1,2,3], -3, 10)
Tensor.From([1, 2, 3], -3, 10) : i8[*,*]
BndKind:Tensor, Type:i8[*,*], Bnd:([!  !]:i8[0,10])
*** Warning: (21,22) Node: -3, Message: Tensor dimension should be non-negative
Func sig: () to i8[*,*]
Ten<i8>(0,10)<0,0> []
###

**** New definitions: x, type: i8

> Tensor.From([1,2,3], x, 10)
Tensor.From([1, 2, 3], x, 10) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.From([1:i8, 2:i8, 3:i8]:i8*, Global(x), 10:i8):i8[*,*]))
Func sig: (<ctx>:x, x:i8) to i8[*,*]
Ten<i8>(0,10)<0,0> []
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)->Reshape(3, 4)
Range(12)->Tensor.From(4, 3)->Reshape(3, 4) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*]), 3:i8, 4:i8):i8[*,*]))
Func sig: (<ctx>:x) to i8[*,*]
Ten<i8>(3,4)<4,1>
  [[0, 1, 2, 3]
   [4, 5, 6, 7]
   [8, 9, 10, 11]]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)->Reshape(12)
Range(12)->Tensor.From(4, 3)->Reshape(12) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*]), 12:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)->Reshape(7)
Range(12)->Tensor.From(4, 3)->Reshape(7) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*]), 7:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(7)<1> [0, 1, 2, 3, 4, 5, 6]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)->Reshape()
Range(12)->Tensor.From(4, 3)->Reshape() : i8[]
BndKind:Call, Type:i8[], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*])):i8[]))
Func sig: (<ctx>:x) to i8[]
Ten<i8>()<> [0]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)->Reshape(0, 3)
Range(12)->Tensor.From(4, 3)->Reshape(0, 3) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*]), 0:i8, 3:i8):i8[*,*]))
Func sig: (<ctx>:x) to i8[*,*]
Ten<i8>(0,3)<0,0> []
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)->Reshape(1, 3)
Range(12)->Tensor.From(4, 3)->Reshape(1, 3) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*]), 1:i8, 3:i8):i8[*,*]))
Func sig: (<ctx>:x) to i8[*,*]
Ten<i8>(1,3)<0,1>
  [[0, 1, 2]]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3)->Reshape(5, 2)
Range(12)->Tensor.From(4, 3)->Reshape(5, 2) : i8[*,*]
BndKind:Call, Type:i8[*,*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*]), 5:i8, 2:i8):i8[*,*]))
Func sig: (<ctx>:x) to i8[*,*]
Ten<i8>(5,2)<2,1>
  [[0, 1]
   [2, 3]
   [4, 5]
   [6, 7]
   [8, 9]]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(12)->Reshape(12)
Range(12)->Tensor.From(12)->Reshape(12) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), 12:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
*** Ctx ping count: 0
###
> 7r4->Tensor.Fill()->Reshape()
7->Tensor.Fill()->Reshape() : r4[]
BndKind:Call, Type:r4[], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.Fill(7:r4):r4[])):r4[]))
Func sig: (<ctx>:x) to r4[]
Ten<r4>()<> [7]
*** Ctx ping count: 0
###
> 7r4->Tensor.Fill(2)->Reshape()
7->Tensor.Fill(2)->Reshape() : r4[]
BndKind:Call, Type:r4[], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.Fill(7:r4, 2:i8):r4[*])):r4[]))
Func sig: (<ctx>:x) to r4[]
Ten<r4>()<> [7]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(12)->Reshape(1)->Reshape(12)
Range(12)->Tensor.From(12)->Reshape(1)->Reshape(12) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), 1:i8):i8[*]), 12:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(12)<1> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(12)->Reshape(0)->Reshape(12)
Range(12)->Tensor.From(12)->Reshape(0)->Reshape(12) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), 0:i8):i8[*]), 12:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(12)<1> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(12)->Reshape(0)->Reshape(0)
Range(12)->Tensor.From(12)->Reshape(0)->Reshape(0) : i8[*]
BndKind:Call, Type:i8[*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), 0:i8):i8[*]), 0:i8):i8[*]))
Func sig: (<ctx>:x) to i8[*]
Ten<i8>(0)<0> []
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(12)->Reshape(1,0,0)->Reshape(2,0,0)
Range(12)->Tensor.From(12)->Reshape(1, 0, 0)->Reshape(2, 0, 0) : i8[*,*,*]
BndKind:Call, Type:i8[*,*,*], Bnd:(Call(∂.Tensor.Reshape(Call(∂.Tensor.Reshape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), 1:i8, 0:i8, 0:i8):i8[*,*,*]), 2:i8, 0:i8, 0:i8):i8[*,*,*]))
Func sig: (<ctx>:x) to i8[*,*,*]
Ten<i8>(2,0,0)<0,0,0> []
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3).Shape
Range(12)->Tensor.From(4, 3).Shape : (i8, i8)
BndKind:Call, Type:(i8, i8), Bnd:(Call(∂.Tensor.Shape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*])):(i8, i8)))
Func sig: (<ctx>:x) to (i8, i8)
Type: (i8,i8), Value: (4, 3)
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(Wrap(-1), Wrap(-3)).Shape
Range(12)->Tensor.From(Wrap(-1), Wrap(-3)).Shape : (i8, i8)
BndKind:Call, Type:(i8, i8), Bnd:(Call(∂.Tensor.Shape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), Call(∂.Test.Wrap(-1:i8):i8), Call(∂.Test.Wrap(-3:i8):i8)):i8[*,*])):(i8, i8)))
Func sig: (<ctx>:x) to (i8, i8)
Type: (i8,i8), Value: (0, 0)
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(0).Shape
Range(12)->Tensor.From(0).Shape : (i8)
BndKind:Call, Type:(i8), Bnd:(Call(∂.Tensor.Shape(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 0:i8):i8[*])):(i8)))
Func sig: (<ctx>:x) to (i8)
Type: (i8), Value: (0,)
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(4, 3).Values
Range(12)->Tensor.From(4, 3).Values : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Tensor.Values(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 3:i8):i8[*,*])):i8*))
Func sig: (<ctx>:x) to i8*
Sequence: Seq<i8>
 0) 0
 1) 1
 2) 2
 3) 3
 4) 4
 5) 5
 6) 6
 7) 7
 8) 8
 9) 9
10) 10
11) 11
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(Wrap(-1), Wrap(-3)).Values
Range(12)->Tensor.From(Wrap(-1), Wrap(-3)).Values : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Tensor.Values(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), Call(∂.Test.Wrap(-1:i8):i8), Call(∂.Test.Wrap(-3:i8):i8)):i8[*,*])):i8*))
Func sig: (<ctx>:x) to i8*
Type: <null>, Value: <null>
*** Ctx ping count: 0
###
> Range(12)->Tensor.From(0).Values
Range(12)->Tensor.From(0).Values : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Tensor.Values(Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 0:i8):i8[*])):i8*))
Func sig: (<ctx>:x) to i8*
Type: <null>, Value: <null>
*** Ctx ping count: 0
###

**** New definitions: TN, type: {A:i8, B:s, C:{X:i8}, D:(i8)}[*]?

> Tensor.Values(TN)
Tensor.Values(TN) : {A:i8, B:s, C:{X:i8}, D:(i8)}*
BndKind:Call, Type:{A:i8, B:s, C:{X:i8}, D:(i8)}*, Bnd:(Call(∂.Tensor.Values(Global(TN))))
Func sig: (TN:{A:i8, B:s, C:{X:i8}, D:(i8)}[*]?) to {A:i8, B:s, C:{X:i8}, D:(i8)}*
Type: <null>, Value: <null>
###

**** New definitions: TR, type: i8[*,*]

> TR->Values()
TR->Values() : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Tensor.Values(Global(TR)):i8*))
Func sig: (TR:i8[*,*]) to i8*
Sequence: Seq<i8>
 0) 3
 1) 3
 2) 3
 3) 3
 4) 3
 5) 3
###

**** New definitions: TNR, type: i8[*,*]

> TNR.Values
TNR.Values : i8*
BndKind:Call, Type:i8*, Bnd:(Call(∂.Tensor.Values(Global(TNR)):i8*))
Func sig: (TNR:i8[*,*]) to i8*
Sequence: Seq<i8>
 0) 1
 1) 2
 2) 3
 3) 5
 4) 6
 5) 7
 6) 9
 7) 10
 8) 11
###
> With(t:Range(0)->Tensor.From(), (t, t->Transpose()))
With(t : Range(0)->Tensor.From(), (t, t->Transpose())) : (i8[*], i8[*])
BndKind:Call, Type:(i8[*], i8[*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(0:i8):i8*)):i8[*]), (Scope(1), Scope(1)):(i8[*], i8[*])):(i8[*], i8[*])))
Func sig: (<ctx>:x) to (i8[*], i8[*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(0)<0> [], Ten<i8>(0)<0> [])
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(), (t, t->Transpose()))
With(t : Range(12)->Tensor.From(), (t, t->Transpose())) : (i8[*], i8[*])
BndKind:Call, Type:(i8[*], i8[*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*)):i8[*]), (Scope(1), Scope(1)):(i8[*], i8[*])):(i8[*], i8[*])))
Func sig: (<ctx>:x) to (i8[*], i8[*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(3, 4), (t, t->Transpose()))
With(t : Range(12)->Tensor.From(3, 4), (t, t->Transpose())) : (i8[*,*], i8[*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 3:i8, 4:i8):i8[*,*]), (Scope(1), Call(∂.Tensor.Transpose(Scope(1)):i8[*,*])):(i8[*,*], i8[*,*])):(i8[*,*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(3,4)<4,1>
      [[0, 1, 2, 3]
       [4, 5, 6, 7]
       [8, 9, 10, 11]]
  , Ten<i8>(4,3)<1,4>
      [[0, 4, 8]
       [1, 5, 9]
       [2, 6, 10]
       [3, 7, 11]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(2, 3, 2), (t, t->Transpose()))
With(t : Range(12)->Tensor.From(2, 3, 2), (t, t->Transpose())) : (i8[*,*,*], i8[*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Call(∂.Tensor.Transpose(Scope(1)):i8[*,*,*])):(i8[*,*,*], i8[*,*,*])):(i8[*,*,*], i8[*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,2)<6,2,1>
      [[[0, 1]
        [2, 3]
        [4, 5]]

       [[6, 7]
        [8, 9]
        [10, 11]]]
  , Ten<i8>(2,3,2)<1,2,6>
      [[[0, 6]
        [2, 8]
        [4, 10]]

       [[1, 7]
        [3, 9]
        [5, 11]]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(2, 3, 1, 2), (t, t->Transpose()))
With(t : Range(12)->Tensor.From(2, 3, 1, 2), (t, t->Transpose())) : (i8[*,*,*,*], i8[*,*,*,*])
BndKind:Call, Type:(i8[*,*,*,*], i8[*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 1:i8, 2:i8):i8[*,*,*,*]), (Scope(1), Call(∂.Tensor.Transpose(Scope(1)):i8[*,*,*,*])):(i8[*,*,*,*], i8[*,*,*,*])):(i8[*,*,*,*], i8[*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*,*], i8[*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,1,2)<6,2,0,1>
      [[[[0, 1]]

        [[2, 3]]

        [[4, 5]]]


       [[[6, 7]]

        [[8, 9]]

        [[10, 11]]]]
  , Ten<i8>(2,1,3,2)<1,0,2,6>
      [[[[0, 6]
         [2, 8]
         [4, 10]]]


       [[[1, 7]
         [3, 9]
         [5, 11]]]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(2, 3), (t, t->Transpose()))
With(t : Range(12)->Tensor.From(2, 3), (t, t->Transpose())) : (i8[*,*], i8[*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8):i8[*,*]), (Scope(1), Call(∂.Tensor.Transpose(Scope(1)):i8[*,*])):(i8[*,*], i8[*,*])):(i8[*,*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3)<3,1>
      [[0, 1, 2]
       [3, 4, 5]]
  , Ten<i8>(3,2)<1,3>
      [[0, 3]
       [1, 4]
       [2, 5]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(4, 5), (t, t->Transpose()))
With(t : Range(12)->Tensor.From(4, 5), (t, t->Transpose())) : (i8[*,*], i8[*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 5:i8):i8[*,*]), (Scope(1), Call(∂.Tensor.Transpose(Scope(1)):i8[*,*])):(i8[*,*], i8[*,*])):(i8[*,*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(4,5)<5,1>
      [[0, 1, 2, 3, 4]
       [5, 6, 7, 8, 9]
       [10, 11, 0, 0, 0]
       [0, 0, 0, 0, 0]]
  , Ten<i8>(5,4)<1,5>
      [[0, 5, 10, 0]
       [1, 6, 11, 0]
       [2, 7, 0, 0]
       [3, 8, 0, 0]
       [4, 9, 0, 0]]
)
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(2, 3, 1, 2), t1:t0->Transpose(), t2:t1->Reshape(2, 1, 2, 3), t3:t2->Transpose(), (t0, t1, t2, t3))
With(t0 : Range(12)->Tensor.From(2, 3, 1, 2), t1 : t0->Transpose(), t2 : t1->Reshape(2, 1, 2, 3), t3 : t2->Transpose(), (t0, t1, t2, t3)) : (i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])
BndKind:Call, Type:(i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 1:i8, 2:i8):i8[*,*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1)):i8[*,*,*,*]), [with:3] Call(∂.Tensor.Reshape(Scope(2), 2:i8, 1:i8, 2:i8, 3:i8):i8[*,*,*,*]), (Scope(1), Scope(2), Scope(3), Call(∂.Tensor.Transpose(Scope(3)):i8[*,*,*,*])):(i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])):(i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,1,2)<6,2,0,1>
      [[[[0, 1]]

        [[2, 3]]

        [[4, 5]]]


       [[[6, 7]]

        [[8, 9]]

        [[10, 11]]]]
  , Ten<i8>(2,1,3,2)<1,0,2,6>
      [[[[0, 6]
         [2, 8]
         [4, 10]]]


       [[[1, 7]
         [3, 9]
         [5, 11]]]]
  , Ten<i8>(2,1,2,3)<6,0,3,1>
      [[[[0, 6, 2]
         [8, 4, 10]]]


       [[[1, 7, 3]
         [9, 5, 11]]]]
  , Ten<i8>(3,2,1,2)<1,3,0,6>
      [[[[0, 1]]

        [[8, 9]]]


       [[[6, 7]]

        [[4, 5]]]


       [[[2, 3]]

        [[10, 11]]]]
)
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(2, 3, 1, 2), t1:t0->Transpose(), t2:t1->Reshape(), t3:t2->Transpose(), (t0, t1, t2, t3))
With(t0 : Range(12)->Tensor.From(2, 3, 1, 2), t1 : t0->Transpose(), t2 : t1->Reshape(), t3 : t2->Transpose(), (t0, t1, t2, t3)) : (i8[*,*,*,*], i8[*,*,*,*], i8[], i8[])
BndKind:Call, Type:(i8[*,*,*,*], i8[*,*,*,*], i8[], i8[]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 1:i8, 2:i8):i8[*,*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1)):i8[*,*,*,*]), [with:3] Call(∂.Tensor.Reshape(Scope(2)):i8[]), (Scope(1), Scope(2), Scope(3), Scope(3)):(i8[*,*,*,*], i8[*,*,*,*], i8[], i8[])):(i8[*,*,*,*], i8[*,*,*,*], i8[], i8[])))
Func sig: (<ctx>:x) to (i8[*,*,*,*], i8[*,*,*,*], i8[], i8[])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,1,2)<6,2,0,1>
      [[[[0, 1]]

        [[2, 3]]

        [[4, 5]]]


       [[[6, 7]]

        [[8, 9]]

        [[10, 11]]]]
  , Ten<i8>(2,1,3,2)<1,0,2,6>
      [[[[0, 6]
         [2, 8]
         [4, 10]]]


       [[[1, 7]
         [3, 9]
         [5, 11]]]]
  , Ten<i8>()<> [0], Ten<i8>()<> [0])
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(2, 3), t1:t0->Transpose(), t2:t1->Reshape(4, 3), t3:t2->Transpose(), (t0, t1, t2, t3))
With(t0 : Range(12)->Tensor.From(2, 3), t1 : t0->Transpose(), t2 : t1->Reshape(4, 3), t3 : t2->Transpose(), (t0, t1, t2, t3)) : (i8[*,*], i8[*,*], i8[*,*], i8[*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*], i8[*,*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8):i8[*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1)):i8[*,*]), [with:3] Call(∂.Tensor.Reshape(Scope(2), 4:i8, 3:i8):i8[*,*]), (Scope(1), Scope(2), Scope(3), Call(∂.Tensor.Transpose(Scope(3)):i8[*,*])):(i8[*,*], i8[*,*], i8[*,*], i8[*,*])):(i8[*,*], i8[*,*], i8[*,*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*], i8[*,*], i8[*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3)<3,1>
      [[0, 1, 2]
       [3, 4, 5]]
  , Ten<i8>(3,2)<1,3>
      [[0, 3]
       [1, 4]
       [2, 5]]
  , Ten<i8>(4,3)<3,1>
      [[0, 3, 1]
       [4, 2, 5]
       [0, 0, 0]
       [0, 0, 0]]
  , Ten<i8>(3,4)<1,3>
      [[0, 4, 0, 0]
       [3, 2, 0, 0]
       [1, 5, 0, 0]]
)
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(4, 5), t1:t0->Transpose(), t2:t1->Reshape(4, 3), t3:t2->Transpose(), (t0, t1, t2, t3))
With(t0 : Range(12)->Tensor.From(4, 5), t1 : t0->Transpose(), t2 : t1->Reshape(4, 3), t3 : t2->Transpose(), (t0, t1, t2, t3)) : (i8[*,*], i8[*,*], i8[*,*], i8[*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*], i8[*,*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 4:i8, 5:i8):i8[*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1)):i8[*,*]), [with:3] Call(∂.Tensor.Reshape(Scope(2), 4:i8, 3:i8):i8[*,*]), (Scope(1), Scope(2), Scope(3), Call(∂.Tensor.Transpose(Scope(3)):i8[*,*])):(i8[*,*], i8[*,*], i8[*,*], i8[*,*])):(i8[*,*], i8[*,*], i8[*,*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*], i8[*,*], i8[*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(4,5)<5,1>
      [[0, 1, 2, 3, 4]
       [5, 6, 7, 8, 9]
       [10, 11, 0, 0, 0]
       [0, 0, 0, 0, 0]]
  , Ten<i8>(5,4)<1,5>
      [[0, 5, 10, 0]
       [1, 6, 11, 0]
       [2, 7, 0, 0]
       [3, 8, 0, 0]
       [4, 9, 0, 0]]
  , Ten<i8>(4,3)<3,1>
      [[0, 5, 10]
       [0, 1, 6]
       [11, 0, 2]
       [7, 0, 0]]
  , Ten<i8>(3,4)<1,3>
      [[0, 0, 11, 7]
       [5, 1, 0, 0]
       [10, 6, 2, 0]]
)
*** Ctx ping count: 0
###
> With(t:Range(6)->Tensor.From(3, 4), (t, t->Transpose()))
With(t : Range(6)->Tensor.From(3, 4), (t, t->Transpose())) : (i8[*,*], i8[*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(6:i8):i8*), 3:i8, 4:i8):i8[*,*]), (Scope(1), Call(∂.Tensor.Transpose(Scope(1)):i8[*,*])):(i8[*,*], i8[*,*])):(i8[*,*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(3,4)<4,1>
      [[0, 1, 2, 3]
       [4, 5, 0, 0]
       [0, 0, 0, 0]]
  , Ten<i8>(4,3)<1,4>
      [[0, 4, 0]
       [1, 5, 0]
       [2, 0, 0]
       [3, 0, 0]]
)
*** Ctx ping count: 0
###
> With(t0:3->Tensor.Fill(2, 4, 3), t1:t0->Transpose(), t2:t1->Reshape(4, 3, 2), t3:t2->Transpose(), (t0, t1, t2, t3))
With(t0 : 3->Tensor.Fill(2, 4, 3), t1 : t0->Transpose(), t2 : t1->Reshape(4, 3, 2), t3 : t2->Transpose(), (t0, t1, t2, t3)) : (i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8, 2:i8, 4:i8, 3:i8):i8[*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1)):i8[*,*,*]), [with:3] Call(∂.Tensor.Reshape(Scope(2), 4:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Scope(2), Scope(3), Call(∂.Tensor.Transpose(Scope(3)):i8[*,*,*])):(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])):(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,4,3)<0,0,0>
      [[[3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]]

       [[3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]]]
  , Ten<i8>(3,4,2)<0,0,0>
      [[[3, 3]
        [3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]
        [3, 3]]]
  , Ten<i8>(4,3,2)<0,0,0>
      [[[3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]]]
  , Ten<i8>(2,3,4)<0,0,0>
      [[[3, 3, 3, 3]
        [3, 3, 3, 3]
        [3, 3, 3, 3]]

       [[3, 3, 3, 3]
        [3, 3, 3, 3]
        [3, 3, 3, 3]]]
)
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(12), t1:t0->Transpose(0), t2:t1->Transpose(0), (t0, t1, t2))
With(t0 : Range(12)->Tensor.From(12), t1 : t0->Transpose(0), t2 : t1->Transpose(0), (t0, t1, t2)) : (i8[*], i8[*], i8[*])
BndKind:Call, Type:(i8[*], i8[*], i8[*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), (Scope(1), Scope(1), Scope(1)):(i8[*], i8[*], i8[*])):(i8[*], i8[*], i8[*])))
Func sig: (<ctx>:x) to (i8[*], i8[*], i8[*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(3,4), t1:t0->Transpose(1,0), t2:t1->Transpose(1,0), (t0, t1, t2))
With(t0 : Range(12)->Tensor.From(3, 4), t1 : t0->Transpose(1, 0), t2 : t1->Transpose(1, 0), (t0, t1, t2)) : (i8[*,*], i8[*,*], i8[*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 3:i8, 4:i8):i8[*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1), 1:i8, 0:i8):i8[*,*]), (Scope(1), Scope(2), Call(∂.Tensor.Transpose(Scope(2), 1:i8, 0:i8):i8[*,*])):(i8[*,*], i8[*,*], i8[*,*])):(i8[*,*], i8[*,*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*], i8[*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(3,4)<4,1>
      [[0, 1, 2, 3]
       [4, 5, 6, 7]
       [8, 9, 10, 11]]
  , Ten<i8>(4,3)<1,4>
      [[0, 4, 8]
       [1, 5, 9]
       [2, 6, 10]
       [3, 7, 11]]
  , Ten<i8>(3,4)<4,1>
      [[0, 1, 2, 3]
       [4, 5, 6, 7]
       [8, 9, 10, 11]]
)
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(2,3,2), t1:t0->Transpose(2,0,1), t2:t1->Transpose(2,0,1), t3:t2->Transpose(2,0,1), (t0, t1, t2, t3))
With(t0 : Range(12)->Tensor.From(2, 3, 2), t1 : t0->Transpose(2, 0, 1), t2 : t1->Transpose(2, 0, 1), t3 : t2->Transpose(2, 0, 1), (t0, t1, t2, t3)) : (i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 2:i8):i8[*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1), 2:i8, 0:i8, 1:i8):i8[*,*,*]), [with:3] Call(∂.Tensor.Transpose(Scope(2), 2:i8, 0:i8, 1:i8):i8[*,*,*]), (Scope(1), Scope(2), Scope(3), Call(∂.Tensor.Transpose(Scope(3), 2:i8, 0:i8, 1:i8):i8[*,*,*])):(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])):(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,2)<6,2,1>
      [[[0, 1]
        [2, 3]
        [4, 5]]

       [[6, 7]
        [8, 9]
        [10, 11]]]
  , Ten<i8>(2,2,3)<1,6,2>
      [[[0, 2, 4]
        [6, 8, 10]]

       [[1, 3, 5]
        [7, 9, 11]]]
  , Ten<i8>(3,2,2)<2,1,6>
      [[[0, 6]
        [1, 7]]

       [[2, 8]
        [3, 9]]

       [[4, 10]
        [5, 11]]]
  , Ten<i8>(2,3,2)<6,2,1>
      [[[0, 1]
        [2, 3]
        [4, 5]]

       [[6, 7]
        [8, 9]
        [10, 11]]]
)
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(2,1,3,2), t1:t0->Transpose(3,1,0,2), t2:t1->Transpose(3,1,0,2), t3:t2->Transpose(3,1,0,2), t4:t3->Transpose(3,1,0,2), (t0, t1, t2, t3, t4))
With(t0 : Range(12)->Tensor.From(2, 1, 3, 2), t1 : t0->Transpose(3, 1, 0, 2), t2 : t1->Transpose(3, 1, 0, 2), t3 : t2->Transpose(3, 1, 0, 2), t4 : t3->Transpose(3, 1, 0, 2), (t0, t1, t2, t3, t4)) : (i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])
BndKind:Call, Type:(i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 1:i8, 3:i8, 2:i8):i8[*,*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1), 3:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*]), [with:3] Call(∂.Tensor.Transpose(Scope(2), 3:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*]), [with:4] Call(∂.Tensor.Transpose(Scope(3), 3:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*]), (Scope(1), Scope(2), Scope(3), Scope(4), Call(∂.Tensor.Transpose(Scope(4), 3:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*])):(i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])):(i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*], i8[*,*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,1,3,2)<6,0,2,1>
      [[[[0, 1]
         [2, 3]
         [4, 5]]]


       [[[6, 7]
         [8, 9]
         [10, 11]]]]
  , Ten<i8>(2,1,2,3)<1,0,6,2>
      [[[[0, 2, 4]
         [6, 8, 10]]]


       [[[1, 3, 5]
         [7, 9, 11]]]]
  , Ten<i8>(3,1,2,2)<2,0,1,6>
      [[[[0, 6]
         [1, 7]]]


       [[[2, 8]
         [3, 9]]]


       [[[4, 10]
         [5, 11]]]]
  , Ten<i8>(2,1,3,2)<6,0,2,1>
      [[[[0, 1]
         [2, 3]
         [4, 5]]]


       [[[6, 7]
         [8, 9]
         [10, 11]]]]
  , Ten<i8>(2,1,2,3)<1,0,6,2>
      [[[[0, 2, 4]
         [6, 8, 10]]]


       [[[1, 3, 5]
         [7, 9, 11]]]]
)
*** Ctx ping count: 0
###
> With(t0:Range(60)->Tensor.From(5,2,1,3,2), t1:t0->Transpose(3,4,1,0,2), t2:t1->Transpose(3,4,1,0,2), t3:t2->Transpose(3,4,1,0,2), t4:t3->Transpose(3,4,1,0,2), t5:t4->Transpose(3,4,1,0,2), (t0, t1, t2, t3, t4, t5))
With(t0 : Range(60)->Tensor.From(5, 2, 1, 3, 2), t1 : t0->Transpose(3, 4, 1, 0, 2), t2 : t1->Transpose(3, 4, 1, 0, 2), t3 : t2->Transpose(3, 4, 1, 0, 2), t4 : t3->Transpose(3, 4, 1, 0, 2), t5 : t4->Transpose(3, 4, 1, 0, 2), (t0, t1, t2, t3, t4, t5)) : (i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])
BndKind:Call, Type:(i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(60:i8):i8*), 5:i8, 2:i8, 1:i8, 3:i8, 2:i8):i8[*,*,*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), [with:3] Call(∂.Tensor.Transpose(Scope(2), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), [with:4] Call(∂.Tensor.Transpose(Scope(3), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), [with:5] Call(∂.Tensor.Transpose(Scope(4), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), (Scope(1), Scope(2), Scope(3), Scope(4), Scope(5), Call(∂.Tensor.Transpose(Scope(5), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*])):(i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])):(i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(5,2,1,3,2)<12,6,0,2,1>
      [[[[[0, 1]
          [2, 3]
          [4, 5]]]


        [[[6, 7]
          [8, 9]
          [10, 11]]]]



       [[[[12, 13]
          [14, 15]
          [16, 17]]]


        [[[18, 19]
          [20, 21]
          [22, 23]]]]



       [[[[24, 25]
          [26, 27]
          [28, 29]]]


        [[[30, 31]
          [32, 33]
          [34, 35]]]]



       [[[[36, 37]
          [38, 39]
          [40, 41]]]


        [[[42, 43]
          [44, 45]
          [46, 47]]]]



       [[[[48, 49]
          [50, 51]
          [52, 53]]]


        [[[54, 55]
          [56, 57]
          [58, 59]]]]]
  , Ten<i8>(3,2,2,5,1)<2,1,6,12,0>
      [[[[[0]
          [12]
          [24]
          [36]
          [48]]

         [[6]
          [18]
          [30]
          [42]
          [54]]]


        [[[1]
          [13]
          [25]
          [37]
          [49]]

         [[7]
          [19]
          [31]
          [43]
          [55]]]]



       [[[[2]
          [14]
          [26]
          [38]
          [50]]

         [[8]
          [20]
          [32]
          [44]
          [56]]]


        [[[3]
          [15]
          [27]
          [39]
          [51]]

         [[9]
          [21]
          [33]
          [45]
          [57]]]]



       [[[[4]
          [16]
          [28]
          [40]
          [52]]

         [[10]
          [22]
          [34]
          [46]
          [58]]]


        [[[5]
          [17]
          [29]
          [41]
          [53]]

         [[11]
          [23]
          [35]
          [47]
          [59]]]]]
  , Ten<i8>(5,1,2,3,2)<12,0,1,2,6>
      [[[[[0, 6]
          [2, 8]
          [4, 10]]

         [[1, 7]
          [3, 9]
          [5, 11]]]]



       [[[[12, 18]
          [14, 20]
          [16, 22]]

         [[13, 19]
          [15, 21]
          [17, 23]]]]



       [[[[24, 30]
          [26, 32]
          [28, 34]]

         [[25, 31]
          [27, 33]
          [29, 35]]]]



       [[[[36, 42]
          [38, 44]
          [40, 46]]

         [[37, 43]
          [39, 45]
          [41, 47]]]]



       [[[[48, 54]
          [50, 56]
          [52, 58]]

         [[49, 55]
          [51, 57]
          [53, 59]]]]]
  , Ten<i8>(3,2,1,5,2)<2,6,0,12,1>
      [[[[[0, 1]
          [12, 13]
          [24, 25]
          [36, 37]
          [48, 49]]]


        [[[6, 7]
          [18, 19]
          [30, 31]
          [42, 43]
          [54, 55]]]]



       [[[[2, 3]
          [14, 15]
          [26, 27]
          [38, 39]
          [50, 51]]]


        [[[8, 9]
          [20, 21]
          [32, 33]
          [44, 45]
          [56, 57]]]]



       [[[[4, 5]
          [16, 17]
          [28, 29]
          [40, 41]
          [52, 53]]]


        [[[10, 11]
          [22, 23]
          [34, 35]
          [46, 47]
          [58, 59]]]]]
  , Ten<i8>(5,2,2,3,1)<12,1,6,2,0>
      [[[[[0]
          [2]
          [4]]

         [[6]
          [8]
          [10]]]


        [[[1]
          [3]
          [5]]

         [[7]
          [9]
          [11]]]]



       [[[[12]
          [14]
          [16]]

         [[18]
          [20]
          [22]]]


        [[[13]
          [15]
          [17]]

         [[19]
          [21]
          [23]]]]



       [[[[24]
          [26]
          [28]]

         [[30]
          [32]
          [34]]]


        [[[25]
          [27]
          [29]]

         [[31]
          [33]
          [35]]]]



       [[[[36]
          [38]
          [40]]

         [[42]
          [44]
          [46]]]


        [[[37]
          [39]
          [41]]

         [[43]
          [45]
          [47]]]]



       [[[[48]
          [50]
          [52]]

         [[54]
          [56]
          [58]]]


        [[[49]
          [51]
          [53]]

         [[55]
          [57]
          [59]]]]]
  , Ten<i8>(3,1,2,5,2)<2,0,1,12,6>
      [[[[[0, 6]
          [12, 18]
          [24, 30]
          [36, 42]
          [48, 54]]

         [[1, 7]
          [13, 19]
          [25, 31]
          [37, 43]
          [49, 55]]]]



       [[[[2, 8]
          [14, 20]
          [26, 32]
          [38, 44]
          [50, 56]]

         [[3, 9]
          [15, 21]
          [27, 33]
          [39, 45]
          [51, 57]]]]



       [[[[4, 10]
          [16, 22]
          [28, 34]
          [40, 46]
          [52, 58]]

         [[5, 11]
          [17, 23]
          [29, 35]
          [41, 47]
          [53, 59]]]]]
)
*** Ctx ping count: 0
###
> With(t0:Range(6)->Tensor.From(1,2,1,3,2), t1:t0->Transpose(3,4,1,0,2), t2:t1->Transpose(3,4,1,0,2), t3:t2->Transpose(3,4,1,0,2), t4:t3->Transpose(3,4,1,0,2), t5:t4->Transpose(3,4,1,0,2), (t0, t1, t2, t3, t4, t5))
With(t0 : Range(6)->Tensor.From(1, 2, 1, 3, 2), t1 : t0->Transpose(3, 4, 1, 0, 2), t2 : t1->Transpose(3, 4, 1, 0, 2), t3 : t2->Transpose(3, 4, 1, 0, 2), t4 : t3->Transpose(3, 4, 1, 0, 2), t5 : t4->Transpose(3, 4, 1, 0, 2), (t0, t1, t2, t3, t4, t5)) : (i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])
BndKind:Call, Type:(i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(6:i8):i8*), 1:i8, 2:i8, 1:i8, 3:i8, 2:i8):i8[*,*,*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), [with:3] Call(∂.Tensor.Transpose(Scope(2), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), [with:4] Call(∂.Tensor.Transpose(Scope(3), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), [with:5] Call(∂.Tensor.Transpose(Scope(4), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*]), (Scope(1), Scope(2), Scope(3), Scope(4), Scope(5), Call(∂.Tensor.Transpose(Scope(5), 3:i8, 4:i8, 1:i8, 0:i8, 2:i8):i8[*,*,*,*,*])):(i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])):(i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*], i8[*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(1,2,1,3,2)<0,6,0,2,1>
      [[[[[0, 1]
          [2, 3]
          [4, 5]]]


        [[[0, 0]
          [0, 0]
          [0, 0]]]]]
  , Ten<i8>(3,2,2,1,1)<2,1,6,0,0>
      [[[[[0]]

         [[0]]]


        [[[1]]

         [[0]]]]



       [[[[2]]

         [[0]]]


        [[[3]]

         [[0]]]]



       [[[[4]]

         [[0]]]


        [[[5]]

         [[0]]]]]
  , Ten<i8>(1,1,2,3,2)<0,0,1,2,6>
      [[[[[0, 0]
          [2, 0]
          [4, 0]]

         [[1, 0]
          [3, 0]
          [5, 0]]]]]
  , Ten<i8>(3,2,1,1,2)<2,6,0,0,1>
      [[[[[0, 1]]]


        [[[0, 0]]]]



       [[[[2, 3]]]


        [[[0, 0]]]]



       [[[[4, 5]]]


        [[[0, 0]]]]]
  , Ten<i8>(1,2,2,3,1)<0,1,6,2,0>
      [[[[[0]
          [2]
          [4]]

         [[0]
          [0]
          [0]]]


        [[[1]
          [3]
          [5]]

         [[0]
          [0]
          [0]]]]]
  , Ten<i8>(3,1,2,1,2)<2,0,1,0,6>
      [[[[[0, 0]]

         [[1, 0]]]]



       [[[[2, 0]]

         [[3, 0]]]]



       [[[[4, 0]]

         [[5, 0]]]]]
)
*** Ctx ping count: 0
###
> With(t0:Range(12)->Tensor.From(3,4), t1:t0->Transpose(1,0), t2:t1->Reshape(2,3,2), t3:t2->Transpose(2,0,1), (t0, t1, t2, t3))
With(t0 : Range(12)->Tensor.From(3, 4), t1 : t0->Transpose(1, 0), t2 : t1->Reshape(2, 3, 2), t3 : t2->Transpose(2, 0, 1), (t0, t1, t2, t3)) : (i8[*,*], i8[*,*], i8[*,*,*], i8[*,*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*], i8[*,*,*], i8[*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 3:i8, 4:i8):i8[*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1), 1:i8, 0:i8):i8[*,*]), [with:3] Call(∂.Tensor.Reshape(Scope(2), 2:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Scope(2), Scope(3), Call(∂.Tensor.Transpose(Scope(3), 2:i8, 0:i8, 1:i8):i8[*,*,*])):(i8[*,*], i8[*,*], i8[*,*,*], i8[*,*,*])):(i8[*,*], i8[*,*], i8[*,*,*], i8[*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*], i8[*,*,*], i8[*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(3,4)<4,1>
      [[0, 1, 2, 3]
       [4, 5, 6, 7]
       [8, 9, 10, 11]]
  , Ten<i8>(4,3)<1,4>
      [[0, 4, 8]
       [1, 5, 9]
       [2, 6, 10]
       [3, 7, 11]]
  , Ten<i8>(2,3,2)<6,2,1>
      [[[0, 4]
        [8, 1]
        [5, 9]]

       [[2, 6]
        [10, 3]
        [7, 11]]]
  , Ten<i8>(2,2,3)<1,6,2>
      [[[0, 8, 5]
        [2, 10, 7]]

       [[4, 1, 9]
        [6, 3, 11]]]
)
*** Ctx ping count: 0
###
> With(t0:3->Tensor.Fill(2,4,3), t1:t0->Transpose(2,0,1), t2:t1->Reshape(4, 3, 2), t3:t2->Transpose(1,2,0), (t0, t1, t2, t3))
With(t0 : 3->Tensor.Fill(2, 4, 3), t1 : t0->Transpose(2, 0, 1), t2 : t1->Reshape(4, 3, 2), t3 : t2->Transpose(1, 2, 0), (t0, t1, t2, t3)) : (i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8, 2:i8, 4:i8, 3:i8):i8[*,*,*]), [with:2] Call(∂.Tensor.Transpose(Scope(1), 2:i8, 0:i8, 1:i8):i8[*,*,*]), [with:3] Call(∂.Tensor.Reshape(Scope(2), 4:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Scope(2), Scope(3), Call(∂.Tensor.Transpose(Scope(3), 1:i8, 2:i8, 0:i8):i8[*,*,*])):(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])):(i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*], i8[*,*,*], i8[*,*,*])
Type: (Ten<i8>,Ten<i8>,Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,4,3)<0,0,0>
      [[[3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]]

       [[3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]
        [3, 3, 3]]]
  , Ten<i8>(3,2,4)<0,0,0>
      [[[3, 3, 3, 3]
        [3, 3, 3, 3]]

       [[3, 3, 3, 3]
        [3, 3, 3, 3]]

       [[3, 3, 3, 3]
        [3, 3, 3, 3]]]
  , Ten<i8>(4,3,2)<0,0,0>
      [[[3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]]]
  , Ten<i8>(3,2,4)<0,0,0>
      [[[3, 3, 3, 3]
        [3, 3, 3, 3]]

       [[3, 3, 3, 3]
        [3, 3, 3, 3]]

       [[3, 3, 3, 3]
        [3, 3, 3, 3]]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(12), (t, t->ExpandDims(0)))
With(t : Range(12)->Tensor.From(12), (t, t->ExpandDims(0))) : (i8[*], i8[*,*])
BndKind:Call, Type:(i8[*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 0:i8):i8[*,*])):(i8[*], i8[*,*])):(i8[*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*], i8[*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], Ten<i8>(1,12)<0,1>
      [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(12), (t, t->ExpandDims(1)))
With(t : Range(12)->Tensor.From(12), (t, t->ExpandDims(1))) : (i8[*], i8[*,*])
BndKind:Call, Type:(i8[*], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 1:i8):i8[*,*])):(i8[*], i8[*,*])):(i8[*], i8[*,*])))
Func sig: (<ctx>:x) to (i8[*], i8[*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], Ten<i8>(12,1)<1,0>
      [[0]
       [1]
       [2]
       [3]
       [4]
       [5]
       [6]
       [7]
       [8]
       [9]
       [10]
       [11]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(12), (t, t->ExpandDims(2,0)))
With(t : Range(12)->Tensor.From(12), (t, t->ExpandDims(2, 0))) : (i8[*], i8[*,*,*])
BndKind:Call, Type:(i8[*], i8[*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 12:i8):i8[*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 2:i8, 0:i8):i8[*,*,*])):(i8[*], i8[*,*,*])):(i8[*], i8[*,*,*])))
Func sig: (<ctx>:x) to (i8[*], i8[*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], Ten<i8>(1,12,1)<0,1,0>
      [[[0]
        [1]
        [2]
        [3]
        [4]
        [5]
        [6]
        [7]
        [8]
        [9]
        [10]
        [11]]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(3,4), (t, t->ExpandDims(1,0,4)))
With(t : Range(12)->Tensor.From(3, 4), (t, t->ExpandDims(1, 0, 4))) : (i8[*,*], i8[*,*,*,*,*])
BndKind:Call, Type:(i8[*,*], i8[*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 3:i8, 4:i8):i8[*,*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 1:i8, 0:i8, 4:i8):i8[*,*,*,*,*])):(i8[*,*], i8[*,*,*,*,*])):(i8[*,*], i8[*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*], i8[*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(3,4)<4,1>
      [[0, 1, 2, 3]
       [4, 5, 6, 7]
       [8, 9, 10, 11]]
  , Ten<i8>(1,1,3,4,1)<0,0,4,1,0>
      [[[[[0]
          [1]
          [2]
          [3]]

         [[4]
          [5]
          [6]
          [7]]

         [[8]
          [9]
          [10]
          [11]]]]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(2,3,2), (t, t->ExpandDims(2,0,5)))
With(t : Range(12)->Tensor.From(2, 3, 2), (t, t->ExpandDims(2, 0, 5))) : (i8[*,*,*], i8[*,*,*,*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 2:i8, 0:i8, 5:i8):i8[*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,2)<6,2,1>
      [[[0, 1]
        [2, 3]
        [4, 5]]

       [[6, 7]
        [8, 9]
        [10, 11]]]
  , Ten<i8>(1,2,1,3,2,1)<0,6,0,2,1,0>
      [[[[[[0]
           [1]]

          [[2]
           [3]]

          [[4]
           [5]]]]



        [[[[6]
           [7]]

          [[8]
           [9]]

          [[10]
           [11]]]]]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(2,3,2), (t, t->ExpandDims(2,0,6,1)))
With(t : Range(12)->Tensor.From(2, 3, 2), (t, t->ExpandDims(2, 0, 6, 1))) : (i8[*,*,*], i8[*,*,*,*,*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 2:i8, 0:i8, 6:i8, 1:i8):i8[*,*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,2)<6,2,1>
      [[[0, 1]
        [2, 3]
        [4, 5]]

       [[6, 7]
        [8, 9]
        [10, 11]]]
  , Ten<i8>(1,1,1,2,3,2,1)<0,0,0,6,2,1,0>
      [[[[[[[0]
            [1]]

           [[2]
            [3]]

           [[4]
            [5]]]


          [[[6]
            [7]]

           [[8]
            [9]]

           [[10]
            [11]]]]]]]
)
*** Ctx ping count: 0
###
> With(t:Range(12)->Tensor.From(2,3,2), (t, t->ExpandDims(2,0,6,4,7)))
With(t : Range(12)->Tensor.From(2, 3, 2), (t, t->ExpandDims(2, 0, 6, 4, 7))) : (i8[*,*,*], i8[*,*,*,*,*,*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*,*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(12:i8):i8*), 2:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 2:i8, 0:i8, 6:i8, 4:i8, 7:i8):i8[*,*,*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*,*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,2)<6,2,1>
      [[[0, 1]
        [2, 3]
        [4, 5]]

       [[6, 7]
        [8, 9]
        [10, 11]]]
  , Ten<i8>(1,2,1,3,1,2,1,1)<0,6,0,2,0,1,0,0>
      [[[[[[[[0]]

            [[1]]]]



          [[[[2]]

            [[3]]]]



          [[[[4]]

            [[5]]]]]]





        [[[[[[6]]

            [[7]]]]



          [[[[8]]

            [[9]]]]



          [[[[10]]

            [[11]]]]]]]]
)
*** Ctx ping count: 0
###
> With(t:Range(5)->Tensor.From(2,3,2), (t, t->ExpandDims(0,2,5)))
With(t : Range(5)->Tensor.From(2, 3, 2), (t, t->ExpandDims(0, 2, 5))) : (i8[*,*,*], i8[*,*,*,*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.From(Call(∂.Range(5:i8):i8*), 2:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 0:i8, 2:i8, 5:i8):i8[*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,2)<6,2,1>
      [[[0, 1]
        [2, 3]
        [4, 0]]

       [[0, 0]
        [0, 0]
        [0, 0]]]
  , Ten<i8>(1,2,1,3,2,1)<0,6,0,2,1,0>
      [[[[[[0]
           [1]]

          [[2]
           [3]]

          [[4]
           [0]]]]



        [[[[0]
           [0]]

          [[0]
           [0]]

          [[0]
           [0]]]]]]
)
*** Ctx ping count: 0
###
> With(t:3->Tensor.Fill(2,3,2), (t, t->ExpandDims(0,2,5)))
With(t : 3->Tensor.Fill(2, 3, 2), (t, t->ExpandDims(0, 2, 5))) : (i8[*,*,*], i8[*,*,*,*,*,*])
BndKind:Call, Type:(i8[*,*,*], i8[*,*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8, 2:i8, 3:i8, 2:i8):i8[*,*,*]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 0:i8, 2:i8, 5:i8):i8[*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*])):(i8[*,*,*], i8[*,*,*,*,*,*])))
Func sig: (<ctx>:x) to (i8[*,*,*], i8[*,*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>(2,3,2)<0,0,0>
      [[[3, 3]
        [3, 3]
        [3, 3]]

       [[3, 3]
        [3, 3]
        [3, 3]]]
  , Ten<i8>(1,2,1,3,2,1)<0,0,0,0,0,0>
      [[[[[[3]
           [3]]

          [[3]
           [3]]

          [[3]
           [3]]]]



        [[[[3]
           [3]]

          [[3]
           [3]]

          [[3]
           [3]]]]]]
)
*** Ctx ping count: 0
###
> With(t:3->Tensor.Fill(), (t, t->ExpandDims(0)))
With(t : 3->Tensor.Fill(), (t, t->ExpandDims(0))) : (i8[], i8[*])
BndKind:Call, Type:(i8[], i8[*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8):i8[]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 0:i8):i8[*])):(i8[], i8[*])):(i8[], i8[*])))
Func sig: () to (i8[], i8[*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>()<> [3], Ten<i8>(1)<0> [3])
###
> With(t:3->Tensor.Fill(), (t, t->ExpandDims(1,0)))
With(t : 3->Tensor.Fill(), (t, t->ExpandDims(1, 0))) : (i8[], i8[*,*])
BndKind:Call, Type:(i8[], i8[*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8):i8[]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 1:i8, 0:i8):i8[*,*])):(i8[], i8[*,*])):(i8[], i8[*,*])))
Func sig: () to (i8[], i8[*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>()<> [3], Ten<i8>(1,1)<0,0>
      [[3]]
)
###
> With(t:3->Tensor.Fill(), (t, t->ExpandDims(1,2,0)))
With(t : 3->Tensor.Fill(), (t, t->ExpandDims(1, 2, 0))) : (i8[], i8[*,*,*])
BndKind:Call, Type:(i8[], i8[*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8):i8[]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 1:i8, 2:i8, 0:i8):i8[*,*,*])):(i8[], i8[*,*,*])):(i8[], i8[*,*,*])))
Func sig: () to (i8[], i8[*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>()<> [3], Ten<i8>(1,1,1)<0,0,0>
      [[[3]]]
)
###
> With(t:3->Tensor.Fill(), (t, t->ExpandDims(3,1,2,0)))
With(t : 3->Tensor.Fill(), (t, t->ExpandDims(3, 1, 2, 0))) : (i8[], i8[*,*,*,*])
BndKind:Call, Type:(i8[], i8[*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8):i8[]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 3:i8, 1:i8, 2:i8, 0:i8):i8[*,*,*,*])):(i8[], i8[*,*,*,*])):(i8[], i8[*,*,*,*])))
Func sig: () to (i8[], i8[*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>()<> [3], Ten<i8>(1,1,1,1)<0,0,0,0>
      [[[[3]]]]
)
###
> With(t:3->Tensor.Fill(), (t, t->ExpandDims(3,1,2,4,0)))
With(t : 3->Tensor.Fill(), (t, t->ExpandDims(3, 1, 2, 4, 0))) : (i8[], i8[*,*,*,*,*])
BndKind:Call, Type:(i8[], i8[*,*,*,*,*]), Bnd:(Call(∂.With([with:1] Call(∂.Tensor.Fill(3:i8):i8[]), (Scope(1), Call(∂.Tensor.ExpandDims(Scope(1), 3:i8, 1:i8, 2:i8, 4:i8, 0:i8):i8[*,*,*,*,*])):(i8[], i8[*,*,*,*,*])):(i8[], i8[*,*,*,*,*])))
Func sig: () to (i8[], i8[*,*,*,*,*])
Type: (Ten<i8>,Ten<i8>), Value: (Ten<i8>()<> [3], Ten<i8>(1,1,1,1,1)<0,0,0,0,0>
      [[[[[3]]]]]
)
###
> Range(12)->ScanX(p: Tensor.From([0,1], 2), p->Dot(Tensor.From([0,1,1,1], 2, 2)))
Range(12)->ScanX(p : Tensor.From([0, 1], 2), p->Dot(Tensor.From([0, 1, 1, 1], 2, 2))) : i8[*]*
BndKind:Call, Type:i8[*]*, Bnd:(Call(∂.With([with:1] [! 0:i8, 1:i8, 1:i8, 1:i8 !]:i8[2,2], Call(∂.ScanX([map:2] Call(∂.Range(12:i8):i8*), [iter:3] [! 0:i8, 1:i8 !]:i8[2], Call(∂.Tensor.Dot(Scope(3), Scope(1)):i8[*])):i8[*]*)):i8[*]*))
Func sig: () to i8[*]*
Sequence: Seq<Ten<i8>>
 0) Ten<i8>(2)<1> [0, 1]
 1) Ten<i8>(2)<1> [1, 1]
 2) Ten<i8>(2)<1> [1, 2]
 3) Ten<i8>(2)<1> [2, 3]
 4) Ten<i8>(2)<1> [3, 5]
 5) Ten<i8>(2)<1> [5, 8]
 6) Ten<i8>(2)<1> [8, 13]
 7) Ten<i8>(2)<1> [13, 21]
 8) Ten<i8>(2)<1> [21, 34]
 9) Ten<i8>(2)<1> [34, 55]
10) Ten<i8>(2)<1> [55, 89]
11) Ten<i8>(2)<1> [89, 144]
12) Ten<i8>(2)<1> [144, 233]
###
