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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[*]) to ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(12)<1> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22] },
    { Sub: Ten<u1>(12)<1> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Mul: Ten<u1>(12)<1> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121] },
    { Div: Ten<u1>(12)<1> [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Max: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*], U:u1[*,*]) to ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[0, 2, 4, 6]
           [4, 6, 8, 10]
           [8, 10, 12, 14]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [252, 252, 252, 252]
           [248, 248, 248, 248]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 1, 4, 9]
           [0, 5, 12, 21]
           [0, 9, 20, 33]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 1, 1, 1]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [0, 1, 2, 3]
           [0, 1, 2, 3]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

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

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>(12)<1> [255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] },
    { Sub: Ten<u1>(12)<1> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] },
    { Mul: Ten<u1>(12)<1> [0, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245] },
    { Div: Ten<u1>(12)<1> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Max: Ten<u1>(12)<0> [255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255] })
###

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

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

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>(12)<1> [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] },
    { Sub: Ten<u1>(12)<1> [251, 252, 253, 254, 255, 0, 1, 2, 3, 4, 5, 6] },
    { Mul: Ten<u1>(12)<1> [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55] },
    { Div: Ten<u1>(12)<1> [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5] },
    { Max: Ten<u1>(12)<1> [5, 5, 5, 5, 5, 5, 6, 7, 8, 9, 10, 11] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*], U:u1[*,*]) to ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[5, 6, 7, 8]
           [5, 6, 7, 8]
           [5, 6, 7, 8]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[251, 252, 253, 254]
           [251, 252, 253, 254]
           [251, 252, 253, 254]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 5, 10, 15]
           [0, 5, 10, 15]
           [0, 5, 10, 15]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [0, 1, 2, 3]
           [0, 1, 2, 3]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>(12)<1> [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139] },
    { Sub: Ten<u1>(12)<1> [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139] },
    { Mul: Ten<u1>(12)<1> [0, 128, 0, 128, 0, 128, 0, 128, 0, 128, 0, 128] },
    { Div: Ten<u1>(12)<1> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Max: Ten<u1>(12)<1> [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>(12)<1> [127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138] },
    { Sub: Ten<u1>(12)<1> [129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140] },
    { Mul: Ten<u1>(12)<1> [0, 127, 254, 125, 252, 123, 250, 121, 248, 119, 246, 117] },
    { Div: Ten<u1>(12)<1> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Max: Ten<u1>(12)<1> [127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*]) to ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(3,4)<4,1>
          [[0, 2, 4, 6]
           [4, 6, 8, 10]
           [8, 10, 12, 14]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [4, 4, 4, 4]
           [8, 8, 8, 8]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 1, 4, 9]
           [0, 5, 12, 21]
           [0, 9, 20, 33]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 1, 1, 1]
           [0, 5, 3, 2]
           [0, 9, 5, 3]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [0, 1, 2, 3]
           [0, 1, 2, 3]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*,*]) to ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[0, 2, 4, 6]
           [8, 10, 12, 14]
           [16, 18, 20, 22]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 1, 4, 9]
           [16, 25, 36, 49]
           [64, 81, 100, 121]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*]) to ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(3,4)<4,1>
          [[0, 2, 4, 6]
           [4, 6, 8, 10]
           [8, 10, 12, 14]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [4, 4, 4, 4]
           [8, 8, 8, 8]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 1, 4, 9]
           [0, 5, 12, 21]
           [0, 9, 20, 33]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 1, 1, 1]
           [0, 5, 3, 2]
           [0, 9, 5, 3]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [0, 1, 2, 3]
           [0, 1, 2, 3]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>(3,4)<4,1>
          [[255, 0, 1, 2]
           [3, 4, 5, 6]
           [7, 8, 9, 10]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[1, 2, 3, 4]
           [5, 6, 7, 8]
           [9, 10, 11, 12]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 255, 254, 253]
           [252, 251, 250, 249]
           [248, 247, 246, 245]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[255, 255, 255, 255]
           [255, 255, 255, 255]
           [255, 255, 255, 255]]
    })
###

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

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

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>(3,4)<4,1>
          [[5, 6, 7, 8]
           [9, 10, 11, 12]
           [13, 14, 15, 16]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[251, 252, 253, 254]
           [255, 0, 1, 2]
           [3, 4, 5, 6]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 5, 10, 15]
           [20, 25, 30, 35]
           [40, 45, 50, 55]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 1, 1, 1]
           [1, 1, 2, 2]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[5, 5, 5, 5]
           [5, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*,*]) to ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[5, 6, 7, 8]
           [9, 10, 11, 12]
           [13, 14, 15, 16]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[251, 252, 253, 254]
           [255, 0, 1, 2]
           [3, 4, 5, 6]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 5, 10, 15]
           [20, 25, 30, 35]
           [40, 45, 50, 55]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 1, 1, 1]
           [1, 1, 2, 2]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[5, 5, 5, 5]
           [5, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>(3,4)<4,1>
          [[128, 129, 130, 131]
           [132, 133, 134, 135]
           [136, 137, 138, 139]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[128, 129, 130, 131]
           [132, 133, 134, 135]
           [136, 137, 138, 139]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 128, 0, 128]
           [0, 128, 0, 128]
           [0, 128, 0, 128]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>(3,4)<4,1>
          [[127, 128, 129, 130]
           [131, 132, 133, 134]
           [135, 136, 137, 138]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[129, 130, 131, 132]
           [133, 134, 135, 136]
           [137, 138, 139, 140]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 127, 254, 125]
           [252, 123, 250, 121]
           [248, 119, 246, 117]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    })
###

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*], U:u1[*,*]) to ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[0, 2, 4, 6]
           [4, 6, 8, 10]
           [8, 10, 12, 14]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [252, 252, 252, 252]
           [248, 248, 248, 248]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 1, 4, 9]
           [0, 5, 12, 21]
           [0, 9, 20, 33]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 1, 1, 1]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [0, 1, 2, 3]
           [0, 1, 2, 3]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[*]) to ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(4)<1> [0, 2, 4, 6] },
    { Sub: Ten<u1>(4)<1> [0, 0, 0, 0] },
    { Mul: Ten<u1>(4)<1> [0, 1, 4, 9] },
    { Div: Ten<u1>(4)<1> [0, 1, 1, 1] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<1> [0, 1, 2, 3] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[*]) to ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>(0)<0> [] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>(4)<1> [255, 0, 1, 2] },
    { Sub: Ten<u1>(4)<1> [1, 2, 3, 4] },
    { Mul: Ten<u1>(4)<1> [0, 255, 254, 253] },
    { Div: Ten<u1>(4)<1> [0, 0, 0, 0] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<0> [255, 255, 255, 255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Sub: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Mul: Ten<u1>(4)<0> [0, 0, 0, 0] },
    { Div: Ten<u1>(4)<0> [0, 0, 0, 0] },
    { Min: Ten<u1>(4)<0> [0, 0, 0, 0] },
    { Max: Ten<u1>(4)<1> [0, 1, 2, 3] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>(4)<1> [1, 2, 3, 4] },
    { Sub: Ten<u1>(4)<1> [255, 0, 1, 2] },
    { Mul: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Div: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Min: Ten<u1>(4)<1> [0, 1, 1, 1] },
    { Max: Ten<u1>(4)<1> [1, 1, 2, 3] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>(4)<1> [5, 6, 7, 8] },
    { Sub: Ten<u1>(4)<1> [251, 252, 253, 254] },
    { Mul: Ten<u1>(4)<1> [0, 5, 10, 15] },
    { Div: Ten<u1>(4)<1> [0, 0, 0, 0] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<1> [5, 5, 5, 5] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*], U:u1[*,*]) to ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[5, 6, 7, 8]
           [5, 6, 7, 8]
           [5, 6, 7, 8]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[251, 252, 253, 254]
           [251, 252, 253, 254]
           [251, 252, 253, 254]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 5, 10, 15]
           [0, 5, 10, 15]
           [0, 5, 10, 15]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [0, 1, 2, 3]
           [0, 1, 2, 3]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>(4)<1> [128, 129, 130, 131] },
    { Sub: Ten<u1>(4)<1> [128, 129, 130, 131] },
    { Mul: Ten<u1>(4)<1> [0, 128, 0, 128] },
    { Div: Ten<u1>(4)<1> [0, 0, 0, 0] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<1> [128, 128, 128, 128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(4)<1> [0, 1, 2, 3] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>(4)<1> [127, 128, 129, 130] },
    { Sub: Ten<u1>(4)<1> [129, 130, 131, 132] },
    { Mul: Ten<u1>(4)<1> [0, 127, 254, 125] },
    { Div: Ten<u1>(4)<1> [0, 0, 0, 0] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<1> [127, 127, 127, 127] })
###

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

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

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[*]) to ({'  T':u1[*]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(0)<0> [] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(0)<0> [] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

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

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(0)<0> [] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*], U:u1[*,*]) to ({'  T':u1[*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(0)<0> [] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,0)<0,0> [] },
    { Sub: Ten<u1>(3,0)<0,0> [] },
    { Mul: Ten<u1>(3,0)<0,0> [] },
    { Div: Ten<u1>(3,0)<0,0> [] },
    { Min: Ten<u1>(3,0)<0,0> [] },
    { Max: Ten<u1>(3,0)<0,0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(0)<0> [] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[*], U:u1[]) to ({'  T':u1[*]}, {'  U':u1[]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(0)<0> [] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(12)<1> [255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] },
    { Sub: Ten<u1>(12)<1> [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244] },
    { Mul: Ten<u1>(12)<1> [0, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245] },
    { Div: Ten<u1>(12)<1> [0, 255, 127, 85, 63, 51, 42, 36, 31, 28, 25, 23] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Max: Ten<u1>(12)<0> [255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[255, 0, 1, 2]
           [3, 4, 5, 6]
           [7, 8, 9, 10]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[255, 254, 253, 252]
           [251, 250, 249, 248]
           [247, 246, 245, 244]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 255, 254, 253]
           [252, 251, 250, 249]
           [248, 247, 246, 245]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 255, 127, 85]
           [63, 51, 42, 36]
           [31, 28, 25, 23]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[255, 255, 255, 255]
           [255, 255, 255, 255]
           [255, 255, 255, 255]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(4)<1> [255, 0, 1, 2] },
    { Sub: Ten<u1>(4)<1> [255, 254, 253, 252] },
    { Mul: Ten<u1>(4)<1> [0, 255, 254, 253] },
    { Div: Ten<u1>(4)<1> [0, 255, 127, 85] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<0> [255, 255, 255, 255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>(0)<0> [] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>()<> [254] },
    { Sub: Ten<u1>()<> [0] },
    { Mul: Ten<u1>()<> [1] },
    { Div: Ten<u1>()<> [1] },
    { Min: Ten<u1>()<> [255] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>()<> [255] },
    { Sub: Ten<u1>()<> [255] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>()<> [0] },
    { Sub: Ten<u1>()<> [254] },
    { Mul: Ten<u1>()<> [255] },
    { Div: Ten<u1>()<> [255] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>()<> [4] },
    { Sub: Ten<u1>()<> [250] },
    { Mul: Ten<u1>()<> [251] },
    { Div: Ten<u1>()<> [51] },
    { Min: Ten<u1>()<> [5] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<0,0>
          [[4, 4, 4, 4]
           [4, 4, 4, 4]
           [4, 4, 4, 4]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[250, 250, 250, 250]
           [250, 250, 250, 250]
           [250, 250, 250, 250]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[251, 251, 251, 251]
           [251, 251, 251, 251]
           [251, 251, 251, 251]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[51, 51, 51, 51]
           [51, 51, 51, 51]
           [51, 51, 51, 51]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[255, 255, 255, 255]
           [255, 255, 255, 255]
           [255, 255, 255, 255]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>()<> [127] },
    { Sub: Ten<u1>()<> [127] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [1] },
    { Min: Ten<u1>()<> [128] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [255] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>()<> [126] },
    { Sub: Ten<u1>()<> [128] },
    { Mul: Ten<u1>()<> [129] },
    { Div: Ten<u1>()<> [2] },
    { Min: Ten<u1>()<> [127] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Sub: Ten<u1>(12)<1> [0, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245] },
    { Mul: Ten<u1>(12)<0> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Div: Ten<u1>(12)<0> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Min: Ten<u1>(12)<0> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Max: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[0, 255, 254, 253]
           [252, 251, 250, 249]
           [248, 247, 246, 245]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Sub: Ten<u1>(4)<1> [0, 255, 254, 253] },
    { Mul: Ten<u1>(4)<0> [0, 0, 0, 0] },
    { Div: Ten<u1>(4)<0> [0, 0, 0, 0] },
    { Min: Ten<u1>(4)<0> [0, 0, 0, 0] },
    { Max: Ten<u1>(4)<1> [0, 1, 2, 3] })
###

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>()<> [255] },
    { Sub: Ten<u1>()<> [1] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>()<> [0] },
    { Sub: Ten<u1>()<> [0] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [0] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>()<> [1] },
    { Sub: Ten<u1>()<> [255] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [1] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>()<> [5] },
    { Sub: Ten<u1>()<> [251] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [5] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[251, 251, 251, 251]
           [251, 251, 251, 251]
           [251, 251, 251, 251]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>()<> [128] },
    { Sub: Ten<u1>()<> [128] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [0] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>()<> [127] },
    { Sub: Ten<u1>()<> [129] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(12)<1> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] },
    { Sub: Ten<u1>(12)<1> [1, 0, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246] },
    { Mul: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Div: Ten<u1>(12)<1> [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
    { Min: Ten<u1>(12)<1> [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] },
    { Max: Ten<u1>(12)<1> [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[1, 2, 3, 4]
           [5, 6, 7, 8]
           [9, 10, 11, 12]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[1, 0, 255, 254]
           [253, 252, 251, 250]
           [249, 248, 247, 246]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 1, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[1, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(4)<1> [1, 2, 3, 4] },
    { Sub: Ten<u1>(4)<1> [1, 0, 255, 254] },
    { Mul: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Div: Ten<u1>(4)<1> [0, 1, 0, 0] },
    { Min: Ten<u1>(4)<1> [0, 1, 1, 1] },
    { Max: Ten<u1>(4)<1> [1, 1, 2, 3] })
###

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>()<> [0] },
    { Sub: Ten<u1>()<> [2] },
    { Mul: Ten<u1>()<> [255] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>()<> [1] },
    { Sub: Ten<u1>()<> [1] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [1] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>()<> [2] },
    { Sub: Ten<u1>()<> [0] },
    { Mul: Ten<u1>()<> [1] },
    { Div: Ten<u1>()<> [1] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [1] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>()<> [6] },
    { Sub: Ten<u1>()<> [252] },
    { Mul: Ten<u1>()<> [5] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [5] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<0,0>
          [[6, 6, 6, 6]
           [6, 6, 6, 6]
           [6, 6, 6, 6]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[252, 252, 252, 252]
           [252, 252, 252, 252]
           [252, 252, 252, 252]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[1, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>()<> [129] },
    { Sub: Ten<u1>()<> [129] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [1] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>()<> [128] },
    { Sub: Ten<u1>()<> [130] },
    { Mul: Ten<u1>()<> [127] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(12)<1> [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] },
    { Sub: Ten<u1>(12)<1> [5, 4, 3, 2, 1, 0, 255, 254, 253, 252, 251, 250] },
    { Mul: Ten<u1>(12)<1> [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55] },
    { Div: Ten<u1>(12)<1> [0, 5, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5] },
    { Max: Ten<u1>(12)<1> [5, 5, 5, 5, 5, 5, 6, 7, 8, 9, 10, 11] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[5, 6, 7, 8]
           [9, 10, 11, 12]
           [13, 14, 15, 16]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[5, 4, 3, 2]
           [1, 0, 255, 254]
           [253, 252, 251, 250]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 5, 10, 15]
           [20, 25, 30, 35]
           [40, 45, 50, 55]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 5, 2, 1]
           [1, 1, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[5, 5, 5, 5]
           [5, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(4)<1> [5, 6, 7, 8] },
    { Sub: Ten<u1>(4)<1> [5, 4, 3, 2] },
    { Mul: Ten<u1>(4)<1> [0, 5, 10, 15] },
    { Div: Ten<u1>(4)<1> [0, 5, 2, 1] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<1> [5, 5, 5, 5] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>(0)<0> [] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>()<> [4] },
    { Sub: Ten<u1>()<> [6] },
    { Mul: Ten<u1>()<> [251] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [5] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>()<> [5] },
    { Sub: Ten<u1>()<> [5] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [5] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>()<> [6] },
    { Sub: Ten<u1>()<> [4] },
    { Mul: Ten<u1>()<> [5] },
    { Div: Ten<u1>()<> [5] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [5] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>()<> [10] },
    { Sub: Ten<u1>()<> [0] },
    { Mul: Ten<u1>()<> [25] },
    { Div: Ten<u1>()<> [1] },
    { Min: Ten<u1>()<> [5] },
    { Max: Ten<u1>()<> [5] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<0,0>
          [[10, 10, 10, 10]
           [10, 10, 10, 10]
           [10, 10, 10, 10]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[25, 25, 25, 25]
           [25, 25, 25, 25]
           [25, 25, 25, 25]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[1, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>()<> [133] },
    { Sub: Ten<u1>()<> [133] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [5] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [5] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>()<> [132] },
    { Sub: Ten<u1>()<> [134] },
    { Mul: Ten<u1>()<> [123] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [5] },
    { Max: Ten<u1>()<> [127] })
###

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

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

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*,*]) to ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[5, 6, 7, 8]
           [9, 10, 11, 12]
           [13, 14, 15, 16]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[5, 4, 3, 2]
           [1, 0, 255, 254]
           [253, 252, 251, 250]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 5, 10, 15]
           [20, 25, 30, 35]
           [40, 45, 50, 55]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 5, 2, 1]
           [1, 1, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[5, 5, 5, 5]
           [5, 5, 6, 7]
           [8, 9, 10, 11]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*]) to ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(3,4)<4,1>
          [[5, 6, 7, 8]
           [5, 6, 7, 8]
           [5, 6, 7, 8]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[5, 4, 3, 2]
           [5, 4, 3, 2]
           [5, 4, 3, 2]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 5, 10, 15]
           [0, 5, 10, 15]
           [0, 5, 10, 15]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 5, 2, 1]
           [0, 5, 2, 1]
           [0, 5, 2, 1]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [0, 1, 2, 3]
           [0, 1, 2, 3]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*]) to ({'  T':u1[*,*]}, {'  U':u1[*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>(0)<0> [] },
    { Add: Ten<u1>(3,0)<0,0> [] },
    { Sub: Ten<u1>(3,0)<0,0> [] },
    { Mul: Ten<u1>(3,0)<0,0> [] },
    { Div: Ten<u1>(3,0)<0,0> [] },
    { Min: Ten<u1>(3,0)<0,0> [] },
    { Max: Ten<u1>(3,0)<0,0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>(3,4)<0,0>
          [[4, 4, 4, 4]
           [4, 4, 4, 4]
           [4, 4, 4, 4]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[6, 6, 6, 6]
           [6, 6, 6, 6]
           [6, 6, 6, 6]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[251, 251, 251, 251]
           [251, 251, 251, 251]
           [251, 251, 251, 251]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[255, 255, 255, 255]
           [255, 255, 255, 255]
           [255, 255, 255, 255]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>(3,4)<0,0>
          [[6, 6, 6, 6]
           [6, 6, 6, 6]
           [6, 6, 6, 6]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[4, 4, 4, 4]
           [4, 4, 4, 4]
           [4, 4, 4, 4]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[1, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>(3,4)<0,0>
          [[10, 10, 10, 10]
           [10, 10, 10, 10]
           [10, 10, 10, 10]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[25, 25, 25, 25]
           [25, 25, 25, 25]
           [25, 25, 25, 25]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[1, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[*,*]) to ({'  T':u1[*,*]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<0,0>
          [[10, 10, 10, 10]
           [10, 10, 10, 10]
           [10, 10, 10, 10]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[25, 25, 25, 25]
           [25, 25, 25, 25]
           [25, 25, 25, 25]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[1, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>(3,4)<0,0>
          [[133, 133, 133, 133]
           [133, 133, 133, 133]
           [133, 133, 133, 133]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[133, 133, 133, 133]
           [133, 133, 133, 133]
           [133, 133, 133, 133]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[*,*], U:u1[]) to ({'  T':u1[*,*]}, {'  U':u1[]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>(3,4)<0,0>
          [[132, 132, 132, 132]
           [132, 132, 132, 132]
           [132, 132, 132, 132]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[134, 134, 134, 134]
           [134, 134, 134, 134]
           [134, 134, 134, 134]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[123, 123, 123, 123]
           [123, 123, 123, 123]
           [123, 123, 123, 123]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(12)<1> [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139] },
    { Sub: Ten<u1>(12)<1> [128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117] },
    { Mul: Ten<u1>(12)<1> [0, 128, 0, 128, 0, 128, 0, 128, 0, 128, 0, 128] },
    { Div: Ten<u1>(12)<1> [0, 128, 64, 42, 32, 25, 21, 18, 16, 14, 12, 11] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Max: Ten<u1>(12)<1> [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[128, 129, 130, 131]
           [132, 133, 134, 135]
           [136, 137, 138, 139]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[128, 127, 126, 125]
           [124, 123, 122, 121]
           [120, 119, 118, 117]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 128, 0, 128]
           [0, 128, 0, 128]
           [0, 128, 0, 128]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 128, 64, 42]
           [32, 25, 21, 18]
           [16, 14, 12, 11]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(4)<1> [128, 129, 130, 131] },
    { Sub: Ten<u1>(4)<1> [128, 127, 126, 125] },
    { Mul: Ten<u1>(4)<1> [0, 128, 0, 128] },
    { Div: Ten<u1>(4)<1> [0, 128, 64, 42] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<1> [128, 128, 128, 128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>(0)<0> [] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>()<> [127] },
    { Sub: Ten<u1>()<> [129] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [128] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>()<> [128] },
    { Sub: Ten<u1>()<> [128] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>()<> [129] },
    { Sub: Ten<u1>()<> [127] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [128] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>()<> [133] },
    { Sub: Ten<u1>()<> [123] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [25] },
    { Min: Ten<u1>()<> [5] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<0,0>
          [[133, 133, 133, 133]
           [133, 133, 133, 133]
           [133, 133, 133, 133]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[123, 123, 123, 123]
           [123, 123, 123, 123]
           [123, 123, 123, 123]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[25, 25, 25, 25]
           [25, 25, 25, 25]
           [25, 25, 25, 25]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>()<> [0] },
    { Sub: Ten<u1>()<> [0] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [1] },
    { Min: Ten<u1>()<> [128] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [128] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>()<> [255] },
    { Sub: Ten<u1>()<> [1] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [1] },
    { Min: Ten<u1>()<> [127] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Add: Ten<u1>(12)<1> [127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138] },
    { Sub: Ten<u1>(12)<1> [127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116] },
    { Mul: Ten<u1>(12)<1> [0, 127, 254, 125, 252, 123, 250, 121, 248, 119, 246, 117] },
    { Div: Ten<u1>(12)<1> [0, 127, 63, 42, 31, 25, 21, 18, 15, 14, 12, 11] },
    { Min: Ten<u1>(12)<1> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] },
    { Max: Ten<u1>(12)<1> [127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Add: Ten<u1>(3,4)<4,1>
          [[127, 128, 129, 130]
           [131, 132, 133, 134]
           [135, 136, 137, 138]]
    },
    { Sub: Ten<u1>(3,4)<4,1>
          [[127, 126, 125, 124]
           [123, 122, 121, 120]
           [119, 118, 117, 116]]
    },
    { Mul: Ten<u1>(3,4)<4,1>
          [[0, 127, 254, 125]
           [252, 123, 250, 121]
           [248, 119, 246, 117]]
    },
    { Div: Ten<u1>(3,4)<4,1>
          [[0, 127, 63, 42]
           [31, 25, 21, 18]
           [15, 14, 12, 11]]
    },
    { Min: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { Max: Ten<u1>(3,4)<4,1>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Add: Ten<u1>(4)<1> [127, 128, 129, 130] },
    { Sub: Ten<u1>(4)<1> [127, 126, 125, 124] },
    { Mul: Ten<u1>(4)<1> [0, 127, 254, 125] },
    { Div: Ten<u1>(4)<1> [0, 127, 63, 42] },
    { Min: Ten<u1>(4)<1> [0, 1, 2, 3] },
    { Max: Ten<u1>(4)<1> [127, 127, 127, 127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*])}):({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]}))
Func sig: (T:u1[], U:u1[*]) to ({'  T':u1[]}, {'  U':u1[*]}, {Add:u1[*]}, {Sub:u1[*]}, {Mul:u1[*]}, {Div:u1[*]}, {Min:u1[*]}, {Max:u1[*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>(0)<0> [] },
    { Add: Ten<u1>(0)<0> [] },
    { Sub: Ten<u1>(0)<0> [] },
    { Mul: Ten<u1>(0)<0> [] },
    { Div: Ten<u1>(0)<0> [] },
    { Min: Ten<u1>(0)<0> [] },
    { Max: Ten<u1>(0)<0> [] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>()<> [255] },
    { Add: Ten<u1>()<> [126] },
    { Sub: Ten<u1>()<> [128] },
    { Mul: Ten<u1>()<> [129] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [127] },
    { Max: Ten<u1>()<> [255] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>()<> [0] },
    { Add: Ten<u1>()<> [127] },
    { Sub: Ten<u1>()<> [127] },
    { Mul: Ten<u1>()<> [0] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [0] },
    { Max: Ten<u1>()<> [127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>()<> [1] },
    { Add: Ten<u1>()<> [128] },
    { Sub: Ten<u1>()<> [126] },
    { Mul: Ten<u1>()<> [127] },
    { Div: Ten<u1>()<> [127] },
    { Min: Ten<u1>()<> [1] },
    { Max: Ten<u1>()<> [127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>()<> [5] },
    { Add: Ten<u1>()<> [132] },
    { Sub: Ten<u1>()<> [122] },
    { Mul: Ten<u1>()<> [123] },
    { Div: Ten<u1>()<> [25] },
    { Min: Ten<u1>()<> [5] },
    { Max: Ten<u1>()<> [127] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[*,*])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[*,*])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[*,*])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[*,*])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[*,*])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[*,*])}):({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]}))
Func sig: (T:u1[], U:u1[*,*]) to ({'  T':u1[]}, {'  U':u1[*,*]}, {Add:u1[*,*]}, {Sub:u1[*,*]}, {Mul:u1[*,*]}, {Div:u1[*,*]}, {Min:u1[*,*]}, {Max:u1[*,*]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Add: Ten<u1>(3,4)<0,0>
          [[132, 132, 132, 132]
           [132, 132, 132, 132]
           [132, 132, 132, 132]]
    },
    { Sub: Ten<u1>(3,4)<0,0>
          [[122, 122, 122, 122]
           [122, 122, 122, 122]
           [122, 122, 122, 122]]
    },
    { Mul: Ten<u1>(3,4)<0,0>
          [[123, 123, 123, 123]
           [123, 123, 123, 123]
           [123, 123, 123, 123]]
    },
    { Div: Ten<u1>(3,4)<0,0>
          [[25, 25, 25, 25]
           [25, 25, 25, 25]
           [25, 25, 25, 25]]
    },
    { Min: Ten<u1>(3,4)<0,0>
          [[5, 5, 5, 5]
           [5, 5, 5, 5]
           [5, 5, 5, 5]]
    },
    { Max: Ten<u1>(3,4)<0,0>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>()<> [128] },
    { Add: Ten<u1>()<> [255] },
    { Sub: Ten<u1>()<> [255] },
    { Mul: Ten<u1>()<> [128] },
    { Div: Ten<u1>()<> [0] },
    { Min: Ten<u1>()<> [127] },
    { Max: Ten<u1>()<> [128] })
###

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

> ({'  T': T }, {'  U': U }, {'Add': T->Add(U) }, {'Sub': T->Sub(U) }, {'Mul': T->Mul(U) }, {'Div': T->Div(U) }, {'Min': T->Min(U) }, {'Max': T->Max(U) })
({ '  T' : T }, { '  U' : U }, { 'Add' : T->Add(U) }, { 'Sub' : T->Sub(U) }, { 'Mul' : T->Mul(U) }, { 'Div' : T->Div(U) }, { 'Min' : T->Min(U) }, { 'Max' : T->Max(U) }) : ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
BndKind:Tuple, Type:({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}), Bnd:(({  T:Global(T)}, {  U:Global(U)}, {Add:Call(∂.Tensor.Add(Global(T), Global(U)):u1[])}, {Sub:Call(∂.Tensor.Sub(Global(T), Global(U)):u1[])}, {Mul:Call(∂.Tensor.Mul(Global(T), Global(U)):u1[])}, {Div:Call(∂.Tensor.Div(Global(T), Global(U)):u1[])}, {Min:Call(∂.Tensor.Min(Global(T), Global(U)):u1[])}, {Max:Call(∂.Tensor.Max(Global(T), Global(U)):u1[])}):({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]}))
Func sig: (T:u1[], U:u1[]) to ({'  T':u1[]}, {'  U':u1[]}, {Add:u1[]}, {Sub:u1[]}, {Mul:u1[]}, {Div:u1[]}, {Min:u1[]}, {Max:u1[]})
Type: ({Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>},{Ten<u1>}), Value: (
    {   T: Ten<u1>()<> [127] },
    {   U: Ten<u1>()<> [127] },
    { Add: Ten<u1>()<> [254] },
    { Sub: Ten<u1>()<> [0] },
    { Mul: Ten<u1>()<> [1] },
    { Div: Ten<u1>()<> [1] },
    { Min: Ten<u1>()<> [127] },
    { Max: Ten<u1>()<> [127] })
###
