**** New definitions: T, type: i[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i[*,*]}, {'-T':i[*,*]}, {'~T':i[*,*]})
BndKind:Tuple, Type:({' T':i[*,*]}, {'-T':i[*,*]}, {'~T':i[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i)):i[*,*])}):({' T':i[*,*]}, {'-T':i[*,*]}, {'~T':i[*,*]}))
Func sig: (T:i[*,*]) to ({' T':i[*,*]}, {'-T':i[*,*]}, {'~T':i[*,*]})
Type: ({Ten<ia>},{Ten<ia>},{Ten<ia>}), Value: (
    {  T: Ten<ia>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { -T: Ten<ia>(3,4)<4,1>
          [[0, -1, -2, -3]
           [-4, -5, -6, -7]
           [-8, -9, -10, -11]]
    },
    { ~T: Ten<ia>(3,4)<4,1>
          [[-1, -2, -3, -4]
           [-5, -6, -7, -8]
           [-9, -10, -11, -12]]
    })
###

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

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

**** New definitions: T, type: i4[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]})
BndKind:Tuple, Type:({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i4)):i4[*,*])}):({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]}))
Func sig: (T:i4[*,*]) to ({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]})
Type: ({Ten<i4>},{Ten<i8>},{Ten<i4>}), Value: (
    {  T: Ten<i4>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { -T: Ten<i8>(3,4)<4,1>
          [[0, -1, -2, -3]
           [-4, -5, -6, -7]
           [-8, -9, -10, -11]]
    },
    { ~T: Ten<i4>(3,4)<4,1>
          [[-1, -2, -3, -4]
           [-5, -6, -7, -8]
           [-9, -10, -11, -12]]
    })
###

**** New definitions: T, type: i2[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]})
BndKind:Tuple, Type:({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i2)):i2[*,*])}):({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]}))
Func sig: (T:i2[*,*]) to ({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]})
Type: ({Ten<i2>},{Ten<i8>},{Ten<i2>}), Value: (
    {  T: Ten<i2>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { -T: Ten<i8>(3,4)<4,1>
          [[0, -1, -2, -3]
           [-4, -5, -6, -7]
           [-8, -9, -10, -11]]
    },
    { ~T: Ten<i2>(3,4)<4,1>
          [[-1, -2, -3, -4]
           [-5, -6, -7, -8]
           [-9, -10, -11, -12]]
    })
###

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

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

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]})
BndKind:Tuple, Type:({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 18446744073709551615:u8)):u8[*,*])}):({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]}))
*** Warning: (21,22) Node: T, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
Func sig: (T:u8[*,*]) to ({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]})
Type: ({Ten<u8>},{Ten<i8>},{Ten<u8>}), Value: (
    {  T: Ten<u8>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { -T: Ten<i8>(3,4)<4,1>
          [[0, -1, -2, -3]
           [-4, -5, -6, -7]
           [-8, -9, -10, -11]]
    },
    { ~T: Ten<u8>(3,4)<4,1>
          [[18446744073709551615, 18446744073709551614, 18446744073709551613, 18446744073709551612]
           [18446744073709551611, 18446744073709551610, 18446744073709551609, 18446744073709551608]
           [18446744073709551607, 18446744073709551606, 18446744073709551605, 18446744073709551604]]
    })
###

**** New definitions: T, type: u4[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]})
BndKind:Tuple, Type:({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 4294967295:u4)):u4[*,*])}):({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]}))
Func sig: (T:u4[*,*]) to ({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]})
Type: ({Ten<u4>},{Ten<i8>},{Ten<u4>}), Value: (
    {  T: Ten<u4>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { -T: Ten<i8>(3,4)<4,1>
          [[0, -1, -2, -3]
           [-4, -5, -6, -7]
           [-8, -9, -10, -11]]
    },
    { ~T: Ten<u4>(3,4)<4,1>
          [[4294967295, 4294967294, 4294967293, 4294967292]
           [4294967291, 4294967290, 4294967289, 4294967288]
           [4294967287, 4294967286, 4294967285, 4294967284]]
    })
###

**** New definitions: T, type: u2[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]})
BndKind:Tuple, Type:({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 65535:u2)):u2[*,*])}):({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]}))
Func sig: (T:u2[*,*]) to ({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]})
Type: ({Ten<u2>},{Ten<i8>},{Ten<u2>}), Value: (
    {  T: Ten<u2>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { -T: Ten<i8>(3,4)<4,1>
          [[0, -1, -2, -3]
           [-4, -5, -6, -7]
           [-8, -9, -10, -11]]
    },
    { ~T: Ten<u2>(3,4)<4,1>
          [[65535, 65534, 65533, 65532]
           [65531, 65530, 65529, 65528]
           [65527, 65526, 65525, 65524]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]})
BndKind:Tuple, Type:({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 255:u1)):u1[*,*])}):({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]}))
Func sig: (T:u1[*,*]) to ({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]})
Type: ({Ten<u1>},{Ten<i8>},{Ten<u1>}), Value: (
    {  T: Ten<u1>(3,4)<4,1>
          [[0, 1, 2, 3]
           [4, 5, 6, 7]
           [8, 9, 10, 11]]
    },
    { -T: Ten<i8>(3,4)<4,1>
          [[0, -1, -2, -3]
           [-4, -5, -6, -7]
           [-8, -9, -10, -11]]
    },
    { ~T: Ten<u1>(3,4)<4,1>
          [[255, 254, 253, 252]
           [251, 250, 249, 248]
           [247, 246, 245, 244]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8[*]}, {'-T':i8[*]}, {'~T':i8[*]})
BndKind:Tuple, Type:({' T':i8[*]}, {'-T':i8[*]}, {'~T':i8[*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i8)):i8[*])}):({' T':i8[*]}, {'-T':i8[*]}, {'~T':i8[*]}))
Func sig: (T:i8[*]) to ({' T':i8[*]}, {'-T':i8[*]}, {'~T':i8[*]})
Type: ({Ten<i8>},{Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(4)<1> [0, 1, 2, 3] },
    { -T: Ten<i8>(4)<1> [0, -1, -2, -3] },
    { ~T: Ten<i8>(4)<1> [-1, -2, -3, -4] })
###

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

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

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
BndKind:Tuple, Type:({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i8)):i8[*,*])}):({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}))
Func sig: (T:i8[*,*]) to ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
Type: ({Ten<i8>},{Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(3,4)<0,0>
          [[-1, -1, -1, -1]
           [-1, -1, -1, -1]
           [-1, -1, -1, -1]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[1, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { ~T: Ten<i8>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
BndKind:Tuple, Type:({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i8)):i8[*,*])}):({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}))
Func sig: (T:i8[*,*]) to ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
Type: ({Ten<i8>},{Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { ~T: Ten<i8>(3,4)<0,0>
          [[-1, -1, -1, -1]
           [-1, -1, -1, -1]
           [-1, -1, -1, -1]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
BndKind:Tuple, Type:({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i8)):i8[*,*])}):({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}))
Func sig: (T:i8[*,*]) to ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
Type: ({Ten<i8>},{Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(3,4)<0,0>
          [[1, 1, 1, 1]
           [1, 1, 1, 1]
           [1, 1, 1, 1]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-1, -1, -1, -1]
           [-1, -1, -1, -1]
           [-1, -1, -1, -1]]
    },
    { ~T: Ten<i8>(3,4)<0,0>
          [[-2, -2, -2, -2]
           [-2, -2, -2, -2]
           [-2, -2, -2, -2]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
BndKind:Tuple, Type:({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i8)):i8[*,*])}):({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}))
Func sig: (T:i8[*,*]) to ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
Type: ({Ten<i8>},{Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(3,4)<0,0>
          [[3, 3, 3, 3]
           [3, 3, 3, 3]
           [3, 3, 3, 3]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-3, -3, -3, -3]
           [-3, -3, -3, -3]
           [-3, -3, -3, -3]]
    },
    { ~T: Ten<i8>(3,4)<0,0>
          [[-4, -4, -4, -4]
           [-4, -4, -4, -4]
           [-4, -4, -4, -4]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
BndKind:Tuple, Type:({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i8)):i8[*,*])}):({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}))
Func sig: (T:i8[*,*]) to ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
Type: ({Ten<i8>},{Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(3,4)<0,0>
          [[-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]]
    },
    { ~T: Ten<i8>(3,4)<0,0>
          [[9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
BndKind:Tuple, Type:({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i8)):i8[*,*])}):({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]}))
Func sig: (T:i8[*,*]) to ({' T':i8[*,*]}, {'-T':i8[*,*]}, {'~T':i8[*,*]})
Type: ({Ten<i8>},{Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(3,4)<0,0>
          [[9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-9223372036854775807, -9223372036854775807, -9223372036854775807, -9223372036854775807]
           [-9223372036854775807, -9223372036854775807, -9223372036854775807, -9223372036854775807]
           [-9223372036854775807, -9223372036854775807, -9223372036854775807, -9223372036854775807]]
    },
    { ~T: Ten<i8>(3,4)<0,0>
          [[-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]]
    })
###

**** New definitions: T, type: i4[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]})
BndKind:Tuple, Type:({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i4)):i4[*,*])}):({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]}))
Func sig: (T:i4[*,*]) to ({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]})
Type: ({Ten<i4>},{Ten<i8>},{Ten<i4>}), Value: (
    {  T: Ten<i4>(3,4)<0,0>
          [[-2147483648, -2147483648, -2147483648, -2147483648]
           [-2147483648, -2147483648, -2147483648, -2147483648]
           [-2147483648, -2147483648, -2147483648, -2147483648]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[2147483648, 2147483648, 2147483648, 2147483648]
           [2147483648, 2147483648, 2147483648, 2147483648]
           [2147483648, 2147483648, 2147483648, 2147483648]]
    },
    { ~T: Ten<i4>(3,4)<0,0>
          [[2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]]
    })
###

**** New definitions: T, type: i4[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]})
BndKind:Tuple, Type:({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i4)):i4[*,*])}):({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]}))
Func sig: (T:i4[*,*]) to ({' T':i4[*,*]}, {'-T':i8[*,*]}, {'~T':i4[*,*]})
Type: ({Ten<i4>},{Ten<i8>},{Ten<i4>}), Value: (
    {  T: Ten<i4>(3,4)<0,0>
          [[2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-2147483647, -2147483647, -2147483647, -2147483647]
           [-2147483647, -2147483647, -2147483647, -2147483647]
           [-2147483647, -2147483647, -2147483647, -2147483647]]
    },
    { ~T: Ten<i4>(3,4)<0,0>
          [[-2147483648, -2147483648, -2147483648, -2147483648]
           [-2147483648, -2147483648, -2147483648, -2147483648]
           [-2147483648, -2147483648, -2147483648, -2147483648]]
    })
###

**** New definitions: T, type: i2[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]})
BndKind:Tuple, Type:({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i2)):i2[*,*])}):({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]}))
Func sig: (T:i2[*,*]) to ({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]})
Type: ({Ten<i2>},{Ten<i8>},{Ten<i2>}), Value: (
    {  T: Ten<i2>(3,4)<0,0>
          [[-32768, -32768, -32768, -32768]
           [-32768, -32768, -32768, -32768]
           [-32768, -32768, -32768, -32768]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[32768, 32768, 32768, 32768]
           [32768, 32768, 32768, 32768]
           [32768, 32768, 32768, 32768]]
    },
    { ~T: Ten<i2>(3,4)<0,0>
          [[32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]]
    })
###

**** New definitions: T, type: i2[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]})
BndKind:Tuple, Type:({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i2)):i2[*,*])}):({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]}))
Func sig: (T:i2[*,*]) to ({' T':i2[*,*]}, {'-T':i8[*,*]}, {'~T':i2[*,*]})
Type: ({Ten<i2>},{Ten<i8>},{Ten<i2>}), Value: (
    {  T: Ten<i2>(3,4)<0,0>
          [[32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-32767, -32767, -32767, -32767]
           [-32767, -32767, -32767, -32767]
           [-32767, -32767, -32767, -32767]]
    },
    { ~T: Ten<i2>(3,4)<0,0>
          [[-32768, -32768, -32768, -32768]
           [-32768, -32768, -32768, -32768]
           [-32768, -32768, -32768, -32768]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]})
BndKind:Tuple, Type:({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i1)):i1[*,*])}):({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]}))
Func sig: (T:i1[*,*]) to ({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]})
Type: ({Ten<i1>},{Ten<i8>},{Ten<i1>}), Value: (
    {  T: Ten<i1>(3,4)<0,0>
          [[-128, -128, -128, -128]
           [-128, -128, -128, -128]
           [-128, -128, -128, -128]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    },
    { ~T: Ten<i1>(3,4)<0,0>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]})
BndKind:Tuple, Type:({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), -1:i1)):i1[*,*])}):({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]}))
Func sig: (T:i1[*,*]) to ({' T':i1[*,*]}, {'-T':i8[*,*]}, {'~T':i1[*,*]})
Type: ({Ten<i1>},{Ten<i8>},{Ten<i1>}), Value: (
    {  T: Ten<i1>(3,4)<0,0>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-127, -127, -127, -127]
           [-127, -127, -127, -127]
           [-127, -127, -127, -127]]
    },
    { ~T: Ten<i1>(3,4)<0,0>
          [[-128, -128, -128, -128]
           [-128, -128, -128, -128]
           [-128, -128, -128, -128]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]})
BndKind:Tuple, Type:({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 18446744073709551615:u8)):u8[*,*])}):({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]}))
*** Warning: (21,22) Node: T, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
Func sig: (T:u8[*,*]) to ({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]})
Type: ({Ten<u8>},{Ten<i8>},{Ten<u8>}), Value: (
    {  T: Ten<u8>(3,4)<0,0>
          [[9223372036854775808, 9223372036854775808, 9223372036854775808, 9223372036854775808]
           [9223372036854775808, 9223372036854775808, 9223372036854775808, 9223372036854775808]
           [9223372036854775808, 9223372036854775808, 9223372036854775808, 9223372036854775808]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]
           [-9223372036854775808, -9223372036854775808, -9223372036854775808, -9223372036854775808]]
    },
    { ~T: Ten<u8>(3,4)<0,0>
          [[9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]})
BndKind:Tuple, Type:({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 18446744073709551615:u8)):u8[*,*])}):({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]}))
*** Warning: (21,22) Node: T, Message: Conversion from unsigned to signed integer can reinterpret large values as negative
Func sig: (T:u8[*,*]) to ({' T':u8[*,*]}, {'-T':i8[*,*]}, {'~T':u8[*,*]})
Type: ({Ten<u8>},{Ten<i8>},{Ten<u8>}), Value: (
    {  T: Ten<u8>(3,4)<0,0>
          [[9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]
           [9223372036854775807, 9223372036854775807, 9223372036854775807, 9223372036854775807]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-9223372036854775807, -9223372036854775807, -9223372036854775807, -9223372036854775807]
           [-9223372036854775807, -9223372036854775807, -9223372036854775807, -9223372036854775807]
           [-9223372036854775807, -9223372036854775807, -9223372036854775807, -9223372036854775807]]
    },
    { ~T: Ten<u8>(3,4)<0,0>
          [[9223372036854775808, 9223372036854775808, 9223372036854775808, 9223372036854775808]
           [9223372036854775808, 9223372036854775808, 9223372036854775808, 9223372036854775808]
           [9223372036854775808, 9223372036854775808, 9223372036854775808, 9223372036854775808]]
    })
###

**** New definitions: T, type: u4[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]})
BndKind:Tuple, Type:({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 4294967295:u4)):u4[*,*])}):({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]}))
Func sig: (T:u4[*,*]) to ({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]})
Type: ({Ten<u4>},{Ten<i8>},{Ten<u4>}), Value: (
    {  T: Ten<u4>(3,4)<0,0>
          [[2147483648, 2147483648, 2147483648, 2147483648]
           [2147483648, 2147483648, 2147483648, 2147483648]
           [2147483648, 2147483648, 2147483648, 2147483648]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-2147483648, -2147483648, -2147483648, -2147483648]
           [-2147483648, -2147483648, -2147483648, -2147483648]
           [-2147483648, -2147483648, -2147483648, -2147483648]]
    },
    { ~T: Ten<u4>(3,4)<0,0>
          [[2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]]
    })
###

**** New definitions: T, type: u4[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]})
BndKind:Tuple, Type:({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 4294967295:u4)):u4[*,*])}):({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]}))
Func sig: (T:u4[*,*]) to ({' T':u4[*,*]}, {'-T':i8[*,*]}, {'~T':u4[*,*]})
Type: ({Ten<u4>},{Ten<i8>},{Ten<u4>}), Value: (
    {  T: Ten<u4>(3,4)<0,0>
          [[2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]
           [2147483647, 2147483647, 2147483647, 2147483647]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-2147483647, -2147483647, -2147483647, -2147483647]
           [-2147483647, -2147483647, -2147483647, -2147483647]
           [-2147483647, -2147483647, -2147483647, -2147483647]]
    },
    { ~T: Ten<u4>(3,4)<0,0>
          [[2147483648, 2147483648, 2147483648, 2147483648]
           [2147483648, 2147483648, 2147483648, 2147483648]
           [2147483648, 2147483648, 2147483648, 2147483648]]
    })
###

**** New definitions: T, type: u2[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]})
BndKind:Tuple, Type:({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 65535:u2)):u2[*,*])}):({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]}))
Func sig: (T:u2[*,*]) to ({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]})
Type: ({Ten<u2>},{Ten<i8>},{Ten<u2>}), Value: (
    {  T: Ten<u2>(3,4)<0,0>
          [[32768, 32768, 32768, 32768]
           [32768, 32768, 32768, 32768]
           [32768, 32768, 32768, 32768]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-32768, -32768, -32768, -32768]
           [-32768, -32768, -32768, -32768]
           [-32768, -32768, -32768, -32768]]
    },
    { ~T: Ten<u2>(3,4)<0,0>
          [[32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]]
    })
###

**** New definitions: T, type: u2[*,*]

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]})
BndKind:Tuple, Type:({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 65535:u2)):u2[*,*])}):({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]}))
Func sig: (T:u2[*,*]) to ({' T':u2[*,*]}, {'-T':i8[*,*]}, {'~T':u2[*,*]})
Type: ({Ten<u2>},{Ten<i8>},{Ten<u2>}), Value: (
    {  T: Ten<u2>(3,4)<0,0>
          [[32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]
           [32767, 32767, 32767, 32767]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-32767, -32767, -32767, -32767]
           [-32767, -32767, -32767, -32767]
           [-32767, -32767, -32767, -32767]]
    },
    { ~T: Ten<u2>(3,4)<0,0>
          [[32768, 32768, 32768, 32768]
           [32768, 32768, 32768, 32768]
           [32768, 32768, 32768, 32768]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]})
BndKind:Tuple, Type:({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 255:u1)):u1[*,*])}):({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]}))
Func sig: (T:u1[*,*]) to ({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]})
Type: ({Ten<u1>},{Ten<i8>},{Ten<u1>}), Value: (
    {  T: Ten<u1>(3,4)<0,0>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-128, -128, -128, -128]
           [-128, -128, -128, -128]
           [-128, -128, -128, -128]]
    },
    { ~T: Ten<u1>(3,4)<0,0>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    })
###

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

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]})
BndKind:Tuple, Type:({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<i8>(Scope(1)))):i8[*,*])}, {~T:Call(∂.Tensor.ForEach([ten:2] Global(T), BitXor(Scope(2), 255:u1)):u1[*,*])}):({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]}))
Func sig: (T:u1[*,*]) to ({' T':u1[*,*]}, {'-T':i8[*,*]}, {'~T':u1[*,*]})
Type: ({Ten<u1>},{Ten<i8>},{Ten<u1>}), Value: (
    {  T: Ten<u1>(3,4)<0,0>
          [[127, 127, 127, 127]
           [127, 127, 127, 127]
           [127, 127, 127, 127]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[-127, -127, -127, -127]
           [-127, -127, -127, -127]
           [-127, -127, -127, -127]]
    },
    { ~T: Ten<u1>(3,4)<0,0>
          [[128, 128, 128, 128]
           [128, 128, 128, 128]
           [128, 128, 128, 128]]
    })
###

**** New definitions: T, type: i8

> ({' T': T }, {'-T': -T }, {'~T': ~T})
({ ' T' : T }, { '-T' : -T }, { '~T' : ~T }) : ({' T':i8}, {'-T':i8}, {'~T':i8})
BndKind:Tuple, Type:({' T':i8}, {'-T':i8}, {'~T':i8}), Bnd:(({ T:Global(T)}, {-T:Add([-] Global(T))}, {~T:BitXor(Global(T), -1:i8)}):({' T':i8}, {'-T':i8}, {'~T':i8}))
Func sig: (T:i8) to ({' T':i8}, {'-T':i8}, {'~T':i8})
Type: ({i8},{i8},{i8}), Value: (
    {  T: 5 },
    { -T: -5 },
    { ~T: -6 })
###

**** New definitions: T, type: r8[*,*]

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

**** New definitions: T, type: r4[*,*]

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

**** New definitions: T, type: r8[*,*]

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':r8[*,*]}, {'-T':r8[*,*]})
BndKind:Tuple, Type:({' T':r8[*,*]}, {'-T':r8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):r8[*,*])}):({' T':r8[*,*]}, {'-T':r8[*,*]}))
Func sig: (T:r8[*,*]) to ({' T':r8[*,*]}, {'-T':r8[*,*]})
Type: ({Ten<r8>},{Ten<r8>}), Value: (
    {  T: Ten<r8>(3,4)<0,0>
          [[∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]]
    },
    { -T: Ten<r8>(3,4)<0,0>
          [[-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]]
    })
###

**** New definitions: T, type: r8[*,*]

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':r8[*,*]}, {'-T':r8[*,*]})
BndKind:Tuple, Type:({' T':r8[*,*]}, {'-T':r8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):r8[*,*])}):({' T':r8[*,*]}, {'-T':r8[*,*]}))
Func sig: (T:r8[*,*]) to ({' T':r8[*,*]}, {'-T':r8[*,*]})
Type: ({Ten<r8>},{Ten<r8>}), Value: (
    {  T: Ten<r8>(3,4)<0,0>
          [[-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]]
    },
    { -T: Ten<r8>(3,4)<0,0>
          [[∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]]
    })
###

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

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':i8[*,*]}, {'-T':i8[*,*]})
BndKind:Tuple, Type:({' T':i8[*,*]}, {'-T':i8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):i8[*,*])}):({' T':i8[*,*]}, {'-T':i8[*,*]}))
Func sig: (T:i8[*,*]) to ({' T':i8[*,*]}, {'-T':i8[*,*]})
Type: ({Ten<i8>},{Ten<i8>}), Value: (
    {  T: Ten<i8>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { -T: Ten<i8>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    })
###

**** New definitions: T, type: r8[*,*]

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':r8[*,*]}, {'-T':r8[*,*]})
BndKind:Tuple, Type:({' T':r8[*,*]}, {'-T':r8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Scope(1))):r8[*,*])}):({' T':r8[*,*]}, {'-T':r8[*,*]}))
Func sig: (T:r8[*,*]) to ({' T':r8[*,*]}, {'-T':r8[*,*]})
Type: ({Ten<r8>},{Ten<r8>}), Value: (
    {  T: Ten<r8>(3,4)<0,0>
          [[NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]]
    },
    { -T: Ten<r8>(3,4)<0,0>
          [[NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]]
    })
###

**** New definitions: T, type: r4[*,*]

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':r4[*,*]}, {'-T':r8[*,*]})
BndKind:Tuple, Type:({' T':r4[*,*]}, {'-T':r8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<r8>(Scope(1)))):r8[*,*])}):({' T':r4[*,*]}, {'-T':r8[*,*]}))
Func sig: (T:r4[*,*]) to ({' T':r4[*,*]}, {'-T':r8[*,*]})
Type: ({Ten<r4>},{Ten<r8>}), Value: (
    {  T: Ten<r4>(3,4)<0,0>
          [[∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]]
    },
    { -T: Ten<r8>(3,4)<0,0>
          [[-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]]
    })
###

**** New definitions: T, type: r4[*,*]

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':r4[*,*]}, {'-T':r8[*,*]})
BndKind:Tuple, Type:({' T':r4[*,*]}, {'-T':r8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<r8>(Scope(1)))):r8[*,*])}):({' T':r4[*,*]}, {'-T':r8[*,*]}))
Func sig: (T:r4[*,*]) to ({' T':r4[*,*]}, {'-T':r8[*,*]})
Type: ({Ten<r4>},{Ten<r8>}), Value: (
    {  T: Ten<r4>(3,4)<0,0>
          [[-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]
           [-∞, -∞, -∞, -∞]]
    },
    { -T: Ten<r8>(3,4)<0,0>
          [[∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]
           [∞, ∞, ∞, ∞]]
    })
###

**** New definitions: T, type: r4[*,*]

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':r4[*,*]}, {'-T':r8[*,*]})
BndKind:Tuple, Type:({' T':r4[*,*]}, {'-T':r8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<r8>(Scope(1)))):r8[*,*])}):({' T':r4[*,*]}, {'-T':r8[*,*]}))
Func sig: (T:r4[*,*]) to ({' T':r4[*,*]}, {'-T':r8[*,*]})
Type: ({Ten<r4>},{Ten<r8>}), Value: (
    {  T: Ten<r4>(3,4)<0,0>
          [[0, 0, 0, 0]
           [0, 0, 0, 0]
           [0, 0, 0, 0]]
    },
    { -T: Ten<r8>(3,4)<0,0>
          [[-0, -0, -0, -0]
           [-0, -0, -0, -0]
           [-0, -0, -0, -0]]
    })
###

**** New definitions: T, type: r4[*,*]

> ({' T': T }, {'-T': -T })
({ ' T' : T }, { '-T' : -T }) : ({' T':r4[*,*]}, {'-T':r8[*,*]})
BndKind:Tuple, Type:({' T':r4[*,*]}, {'-T':r8[*,*]}), Bnd:(({ T:Global(T)}, {-T:Call(∂.Tensor.ForEach([ten:1] Global(T), Add([-] Num<r8>(Scope(1)))):r8[*,*])}):({' T':r4[*,*]}, {'-T':r8[*,*]}))
Func sig: (T:r4[*,*]) to ({' T':r4[*,*]}, {'-T':r8[*,*]})
Type: ({Ten<r4>},{Ten<r8>}), Value: (
    {  T: Ten<r4>(3,4)<0,0>
          [[NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]]
    },
    { -T: Ten<r8>(3,4)<0,0>
          [[NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]
           [NaN, NaN, NaN, NaN]]
    })
###
