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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

           [[0]]

           [[0]]]
    })
###

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

           [[0]]

           [[0]]

           [[0]]]
    })
###

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

           [[0, 0, 0, 0]]

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

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

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

           [[0, 0, 0]]

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

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

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


           [[[0]]]


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            [[0]]]


           [[[0]]

            [[0]]]


           [[[0]]

            [[0]]]


           [[[0]]

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

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

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

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

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

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

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

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

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

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

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]})
BndKind:Tuple, Type:({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):i1[*,*,*,*])}):({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]}))
Func sig: (T:i1[*,*,*], U:i1[*,*,*]) to ({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]})
Type: ({Ten<i1>},{Ten<i1>},{Ten<i1>}), Value: (
    {   T: Ten<i1>(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<i1>(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<i1>(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: i1[*,*,*]
**** New definitions: U, type: i1[*,*,*]

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]})
BndKind:Tuple, Type:({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):i1[*,*,*,*])}):({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]}))
Func sig: (T:i1[*,*,*], U:i1[*,*,*]) to ({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]})
Type: ({Ten<i1>},{Ten<i1>},{Ten<i1>}), Value: (
    {   T: Ten<i1>(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<i1>(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<i1>(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: i1[*,*,*]
**** New definitions: U, type: i1[*]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

> ({'  T': T}, {'  U': U }, {Dot: T->Dot(U)})
({ '  T' : T }, { '  U' : U }, { Dot : T->Dot(U) }) : ({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]})
BndKind:Tuple, Type:({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Dot:Call(∂.Tensor.Dot(Global(T), Global(U)):i1[*,*,*,*])}):({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]}))
Func sig: (T:i1[*,*,*], U:i1[*,*,*]) to ({'  T':i1[*,*,*]}, {'  U':i1[*,*,*]}, {Dot:i1[*,*,*,*]})
Type: ({Ten<i1>},{Ten<i1>},{Ten<i1>}), Value: (
    {   T: Ten<i1>(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<i1>(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<i1>(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: i1[*,*,*]
**** New definitions: U, type: i1[*,*,*]

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