**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(4)<0> [0, 0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(1,1)<0,0>
          [[0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,0)<0,0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(5,6)<0,0>
          [[0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>()<> [506] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(4)<1> [20, 23, 26, 29] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(3)<1> [42, 48, 54] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(1,1)<0,0>
          [[0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,0)<0,0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(12)<0> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(12)<1> [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,3)<0,0>
          [[3, 3, 3]
           [3, 3, 3]
           [3, 3, 3]
           [3, 3, 3]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(5,6)<0,0>
          [[12, 12, 12, 12, 12, 12]
           [12, 12, 12, 12, 12, 12]
           [12, 12, 12, 12, 12, 12]
           [12, 12, 12, 12, 12, 12]
           [12, 12, 12, 12, 12, 12]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(3)<1> [14, 38, 62] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(3,4)<4,1>
          [[20, 23, 26, 29]
           [68, 83, 98, 113]
           [116, 143, 170, 197]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(3,3)<3,1>
          [[42, 48, 54]
           [114, 136, 158]
           [186, 224, 262]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(3,1,1)<0,0,0>
          [[[0]]

           [[0]]

           [[0]]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,3,0)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[]) to ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[]) to ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(3,4)<4,1>
          [[0, 3, 6, 9]
           [12, 15, 18, 21]
           [24, 27, 30, 33]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(3,4,3)<1,0,0>
          [[[3, 3, 3]
            [3, 3, 3]
            [3, 3, 3]
            [3, 3, 3]]

           [[27, 27, 27]
            [27, 27, 27]
            [27, 27, 27]
            [27, 27, 27]]

           [[51, 51, 51]
            [51, 51, 51]
            [51, 51, 51]
            [51, 51, 51]]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(3,5,6)<1,0,0>
          [[[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[60, 60, 60, 60, 60, 60]
            [60, 60, 60, 60, 60, 60]
            [60, 60, 60, 60, 60, 60]
            [60, 60, 60, 60, 60, 60]
            [60, 60, 60, 60, 60, 60]]

           [[108, 108, 108, 108, 108, 108]
            [108, 108, 108, 108, 108, 108]
            [108, 108, 108, 108, 108, 108]
            [108, 108, 108, 108, 108, 108]
            [108, 108, 108, 108, 108, 108]]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(4)<0> [0, 0, 0, 0] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(4)<1> [5, 14, 23, 32] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(4,4)<4,1>
          [[20, 23, 26, 29]
           [56, 68, 80, 92]
           [92, 113, 134, 155]
           [128, 158, 188, 218]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(4,3)<3,1>
          [[15, 18, 21]
           [42, 54, 66]
           [69, 90, 111]
           [96, 126, 156]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(4,1,1)<0,0,0>
          [[[0]]

           [[0]]

           [[0]]

           [[0]]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(4,3,0)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[]) to ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(4,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(4)<0> [0, 0, 0, 0] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*], U:u8[]) to ({'  T':u8[*,*]}, {'  U':u8[]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(4,3)<3,1>
          [[0, 3, 6]
           [9, 12, 15]
           [18, 21, 24]
           [27, 30, 33]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[*,*], U:u8[*]) to ({'  T':u8[*,*]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(4)<0> [0, 0, 0, 0] })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,4,3)<1,0,0>
          [[[3, 3, 3]
            [3, 3, 3]
            [3, 3, 3]
            [3, 3, 3]]

           [[21, 21, 21]
            [21, 21, 21]
            [21, 21, 21]
            [21, 21, 21]]

           [[39, 39, 39]
            [39, 39, 39]
            [39, 39, 39]
            [39, 39, 39]]

           [[57, 57, 57]
            [57, 57, 57]
            [57, 57, 57]
            [57, 57, 57]]]
    })
###

**** New definitions: T, type: u8[*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*], U:u8[*,*,*]) to ({'  T':u8[*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(4,5,6)<1,0,0>
          [[[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[48, 48, 48, 48, 48, 48]
            [48, 48, 48, 48, 48, 48]
            [48, 48, 48, 48, 48, 48]
            [48, 48, 48, 48, 48, 48]
            [48, 48, 48, 48, 48, 48]]

           [[84, 84, 84, 84, 84, 84]
            [84, 84, 84, 84, 84, 84]
            [84, 84, 84, 84, 84, 84]
            [84, 84, 84, 84, 84, 84]
            [84, 84, 84, 84, 84, 84]]

           [[120, 120, 120, 120, 120, 120]
            [120, 120, 120, 120, 120, 120]
            [120, 120, 120, 120, 120, 120]
            [120, 120, 120, 120, 120, 120]
            [120, 120, 120, 120, 120, 120]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(1,0)<0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(1,0)<0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(1,0,4)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(1,0,3)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(1,0,1,1)<0,0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(1,0,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(1,0)<0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(1,0)<0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(1,0,4,3)<0,0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(1,0,1)<0,0,0> [] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(1,0,5,6)<0,0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(3,1)<0,0>
          [[0]
           [0]
           [0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(3,1)<0,0>
          [[0]
           [0]
           [0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(3,1,4)<0,0,0>
          [[[0, 0, 0, 0]]

           [[0, 0, 0, 0]]

           [[0, 0, 0, 0]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(3,1,3)<0,0,0>
          [[[0, 0, 0]]

           [[0, 0, 0]]

           [[0, 0, 0]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(3,1,1,1)<0,0,0,0>
          [[[[0]]]


           [[[0]]]


           [[[0]]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,1,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(3,1)<0,0>
          [[0]
           [0]
           [0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(3,1)<0,0>
          [[0]
           [0]
           [0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(3,1,4,3)<0,0,0,0>
          [[[[0, 0, 0]
             [0, 0, 0]
             [0, 0, 0]
             [0, 0, 0]]]


           [[[0, 0, 0]
             [0, 0, 0]
             [0, 0, 0]
             [0, 0, 0]]]


           [[[0, 0, 0]
             [0, 0, 0]
             [0, 0, 0]
             [0, 0, 0]]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3,1,0)<0,0,0> [] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(3,1,5,6)<0,0,0,0>
          [[[[0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]]]


           [[[0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]]]


           [[[0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0]]]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(12)<0> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[], U:u8[*,*]) to ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[], U:u8[*,*]) to ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(4,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[])}):({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}))
Func sig: (T:u8[], U:u8[]) to ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[])}):({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}))
Func sig: (T:u8[], U:u8[]) to ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,2,3)<0,0,0>
          [[[0, 0, 0]
            [0, 0, 0]]

           [[0, 0, 0]
            [0, 0, 0]]

           [[0, 0, 0]
            [0, 0, 0]]

           [[0, 0, 0]
            [0, 0, 0]]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [0] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(5,3,6)<0,0,0>
          [[[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(4)<0> [0, 0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(1,1)<0,0>
          [[0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,0)<0,0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(3)<0> [0, 0, 0] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(5,6)<0,0>
          [[0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(12)<1> [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[], U:u8[*,*]) to ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(3,4)<4,1>
          [[0, 3, 6, 9]
           [12, 15, 18, 21]
           [24, 27, 30, 33]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*])}):({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[], U:u8[*,*]) to ({'  T':u8[]}, {'  U':u8[*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(4,3)<3,1>
          [[0, 3, 6]
           [9, 12, 15]
           [18, 21, 24]
           [27, 30, 33]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(1,0,1)<0,0,0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,1,0)<0,0,0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[])}):({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}))
Func sig: (T:u8[], U:u8[]) to ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[])}):({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]}))
Func sig: (T:u8[], U:u8[]) to ({'  T':u8[]}, {'  U':u8[]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>()<> [9] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]}))
Func sig: (T:u8[], U:u8[*]) to ({'  T':u8[]}, {'  U':u8[*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,2,3)<0,0,0>
          [[[9, 9, 9]
            [9, 9, 9]]

           [[9, 9, 9]
            [9, 9, 9]]

           [[9, 9, 9]
            [9, 9, 9]]

           [[9, 9, 9]
            [9, 9, 9]]]
    })
###

**** New definitions: T, type: u8[]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[], U:u8[*,*,*]) to ({'  T':u8[]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>()<> [3] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(5,3,6)<0,0,0>
          [[[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(4)<0> [0, 0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(3)<0> [0, 0, 0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(1,1)<0,0>
          [[0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(3,0)<0,0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*])}):({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]}))
Func sig: (T:u8[*], U:u8[]) to ({'  T':u8[*]}, {'  U':u8[]}, {Dot:u8[*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(0)<0> [] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[])}):({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]}))
Func sig: (T:u8[*], U:u8[*]) to ({'  T':u8[*]}, {'  U':u8[*]}, {Dot:u8[]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>()<> [0] })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*], U:u8[*,*,*]) to ({'  T':u8[*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(0)<0> [] },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(5,6)<0,0>
          [[0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]
           [0, 0, 0, 0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(4,2)<0,0>
          [[0, 0]
           [0, 0]
           [0, 0]
           [0, 0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(4,2)<0,0>
          [[9, 9]
           [9, 9]
           [9, 9]
           [9, 9]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(4,2,4)<0,0,1>
          [[[36, 45, 54, 63]
            [36, 45, 54, 63]]

           [[36, 45, 54, 63]
            [36, 45, 54, 63]]

           [[36, 45, 54, 63]
            [36, 45, 54, 63]]

           [[36, 45, 54, 63]
            [36, 45, 54, 63]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(4,2,3)<0,0,1>
          [[[27, 36, 45]
            [27, 36, 45]]

           [[27, 36, 45]
            [27, 36, 45]]

           [[27, 36, 45]
            [27, 36, 45]]

           [[27, 36, 45]
            [27, 36, 45]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(4,2,1,1)<0,0,0,0>
          [[[[0]]

            [[0]]]


           [[[0]]

            [[0]]]


           [[[0]]

            [[0]]]


           [[[0]]

            [[0]]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(4,2,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(4,2,3)<0,0,0>
          [[[0, 0, 0]
            [0, 0, 0]]

           [[0, 0, 0]
            [0, 0, 0]]

           [[0, 0, 0]
            [0, 0, 0]]

           [[0, 0, 0]
            [0, 0, 0]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(4,2)<0,0>
          [[0, 0]
           [0, 0]
           [0, 0]
           [0, 0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(4,2,3)<0,0,0>
          [[[9, 9, 9]
            [9, 9, 9]]

           [[9, 9, 9]
            [9, 9, 9]]

           [[9, 9, 9]
            [9, 9, 9]]

           [[9, 9, 9]
            [9, 9, 9]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(4,2)<0,0>
          [[0, 0]
           [0, 0]
           [0, 0]
           [0, 0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(4,2,4,3)<0,0,0,0>
          [[[[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]

            [[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]]


           [[[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]

            [[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]]


           [[[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]

            [[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]]


           [[[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]

            [[18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]
             [18, 18, 18]]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(4,2,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]]]
    },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(4,2,5,6)<0,0,0,0>
          [[[[36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]]

            [[36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]]]


           [[[36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]]

            [[36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]]]


           [[[36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]]

            [[36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]]]


           [[[36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, 36, 36, 36, 36]
             [36, 36, ...]]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(5,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Dot: Ten<u8>(5,3)<0,0>
          [[60, 60, 60]
           [60, 60, 60]
           [60, 60, 60]
           [60, 60, 60]
           [60, 60, 60]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Dot: Ten<u8>(5,3,4)<0,0,1>
          [[[48, 60, 72, 84]
            [48, 60, 72, 84]
            [48, 60, 72, 84]]

           [[48, 60, 72, 84]
            [48, 60, 72, 84]
            [48, 60, 72, 84]]

           [[48, 60, 72, 84]
            [48, 60, 72, 84]
            [48, 60, 72, 84]]

           [[48, 60, 72, 84]
            [48, 60, 72, 84]
            [48, 60, 72, 84]]

           [[48, 60, 72, 84]
            [48, 60, 72, 84]
            [48, 60, 72, 84]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(4,3)<3,1>
          [[0, 1, 2]
           [3, 4, 5]
           [6, 7, 8]
           [9, 10, 11]]
    },
    { Dot: Ten<u8>(5,3,3)<0,0,1>
          [[[72, 88, 104]
            [72, 88, 104]
            [72, 88, 104]]

           [[72, 88, 104]
            [72, 88, 104]
            [72, 88, 104]]

           [[72, 88, 104]
            [72, 88, 104]
            [72, 88, 104]]

           [[72, 88, 104]
            [72, 88, 104]
            [72, 88, 104]]

           [[72, 88, 104]
            [72, 88, 104]
            [72, 88, 104]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(1,0,1)<0,0,0> [] },
    { Dot: Ten<u8>(5,3,1,1)<0,0,0,0>
          [[[[0]]

            [[0]]

            [[0]]]


           [[[0]]

            [[0]]

            [[0]]]


           [[[0]]

            [[0]]

            [[0]]]


           [[[0]]

            [[0]]

            [[0]]]


           [[[0]]

            [[0]]

            [[0]]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(3,1,0)<0,0,0> [] },
    { Dot: Ten<u8>(5,3,3,0)<0,0,0,0> [] })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>()<> [0] },
    { Dot: Ten<u8>(5,3,6)<0,0,0>
          [[[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]

           [[0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]
            [0, 0, 0, 0, 0, 0]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(3)<0> [0, 0, 0] },
    { Dot: Ten<u8>(5,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Mul(Global(T), Global(U)):u8[*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[]) to ({'  T':u8[*,*,*]}, {'  U':u8[]}, {Dot:u8[*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>()<> [3] },
    { Dot: Ten<u8>(5,3,6)<0,0,0>
          [[[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]

           [[12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]
            [12, 12, 12, 12, 12, 12]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*]}, {Dot:u8[*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(0)<0> [] },
    { Dot: Ten<u8>(5,3)<0,0>
          [[0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]
           [0, 0, 0]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(4,2,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]]]
    },
    { Dot: Ten<u8>(5,3,4,3)<0,0,0,0>
          [[[[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]]


           [[[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]]


           [[[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]]


           [[[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]]


           [[[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]

            [[24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]
             [24, 24, 24]]]]
    })
###

**** New definitions: T, type: u8[*,*,*]
**** New definitions: U, type: u8[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
BndKind:Tuple, Type:({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):u8[*,*,*,*])}):({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]}))
Func sig: (T:u8[*,*,*], U:u8[*,*,*]) to ({'  T':u8[*,*,*]}, {'  U':u8[*,*,*]}, {Dot:u8[*,*,*,*]})
Type: ({Ten<u8>},{Ten<u8>},{Ten<u8>}), Value: (
    {   T: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    {   U: Ten<u8>(5,3,6)<0,0,0>
          [[[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]

           [[4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]
            [4, 4, 4, 4, 4, 4]]]
    },
    { Dot: Ten<u8>(5,3,5,6)<0,0,0,0>
          [[[[48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]]

            [[48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]]

            [[48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]]]


           [[[48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]]

            [[48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]]

            [[48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]]]


           [[[48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, 48, 48, 48, 48]
             [48, 48, ...]]]]
    })
###
