**** New globals: {T:i8[*,*], U:s[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Add(T, Error(ErrBadType_Src_Dst))
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Sub(T, Error(ErrBadType_Src_Dst))
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Mul(T, Error(ErrBadType_Src_Dst))
###
> T->Min(U)
T->Min(U) : i8[*,*]
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Min(T, Error(ErrBadType_Src_Dst))
###
> T->Max(U)
T->Max(U) : i8[*,*]
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Max(T, Error(ErrBadType_Src_Dst))
###
> T->Div(U)
T->Div(U) : i8[*,*]
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Div(T, Error(ErrBadType_Src_Dst))
###
> T->Divide(U)
T->Divide(U) : r8[*,*]
*** Error: (10,11) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: T, Num<r8>(@1)), Error(ErrBadType_Src_Dst))
###
> U->Add(T)
U->Add(T) : i8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Add(Error(ErrBadType_Src_Dst), T)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Sub(Error(ErrBadType_Src_Dst), T)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Mul(Error(ErrBadType_Src_Dst), T)
###
> U->Min(T)
U->Min(T) : i8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Min(Error(ErrBadType_Src_Dst), T)
###
> U->Max(T)
U->Max(T) : i8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Max(Error(ErrBadType_Src_Dst), T)
###
> U->Div(T)
U->Div(T) : i8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Div(Error(ErrBadType_Src_Dst), T)
###
> U->Divide(T)
U->Divide(T) : r8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Divide(Error(ErrBadType_Src_Dst), Tensor.ForEachLazy(@1: T, Num<r8>(@1)))
###
> U->Add(U)
U->Add(U) : r8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Add(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> U->Sub(U)
U->Sub(U) : r8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Sub(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> U->Mul(U)
U->Mul(U) : r8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Mul(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> U->Min(U)
U->Min(U) : r8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Min(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> U->Max(U)
U->Max(U) : r8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Max(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> U->Div(U)
U->Div(U) : i8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
*** Error: (7,8) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Div(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> U->Divide(U)
U->Divide(U) : r8[*,*]
*** Error: (0,1) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
*** Error: (10,11) Node: U, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Divide(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###

**** New globals: {QT:i8[*,*]?, QTs:i8[*,*]?*, R:{A:i4}, T:i8[*,*], Ts:i8[*,*]*, U:i4[*,*], V:s[*,*], i4:i4}

> T->Add(T)
T->Add(T) : i8[*,*]
Binder : Tensor.Add(T, T)
###
> T->Add(Ts)
T->Add(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Add(T, *1))
###
> T->Add(QT)
T->Add(QT) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Add(T, ?1))
###
> T->Add(QTs)
T->Add(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: *1, Tensor.Add(T, ?2)))
###
> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> T->Add(V)
T->Add(V) : i8[*,*]
*** Error: (7,8) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Add(T, Error(ErrBadType_Src_Dst))
###
> T->Add(R)
T->Add(R) : i8[*,*]
*** Error: (7,8) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Tensor.Add(T, Error(ErrBadType_Src_Dst))
###
> T->Add(i4)
T->Add(i4) : i8[*,*]
*** Error: (7,9) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Add(T, Error(ErrBadType_Src_Dst))
###
> Ts->Add(T)
Ts->Add(T) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Add(*1, T))
###
> Ts->Add(Ts)
Ts->Add(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, *2: Ts, Tensor.Add(*1, *2))
Reducer: ForEach(*1: Ts, Tensor.Add(*1, *1))
###
> Ts->Add(QT)
Ts->Add(QT) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Add(*1, ?2)))
###
> Ts->Add(QTs)
Ts->Add(QTs) : i8[*,*]?*
Binder : ForEach(*1: Ts, *2: QTs, Guard(?3: *2, Tensor.Add(*1, ?3)))
###
> Ts->Add(U)
Ts->Add(U) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Add(*1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
Hoister: With(!2: Tensor.ForEachLazy(@1: U, Num<i8>(@1)), ForEach(*3: Ts, Tensor.Add(*3, !2)))
###
> Ts->Add(V)
Ts->Add(V) : i8[*,*]*
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : ForEach(*1: Ts, Tensor.Add(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Add(R)
Ts->Add(R) : i8[*,*]*
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Add(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Add(i4)
Ts->Add(i4) : i8[*,*]*
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Add(*1, Error(ErrBadType_Src_Dst)))
###
> QT->Add(T)
QT->Add(T) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Add(?1, T))
###
> QT->Add(Ts)
QT->Add(Ts) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Add(?2, *1)))
###
> QT->Add(QT)
QT->Add(QT) : i8[*,*]?
Binder : Guard(?1: QT, ?2: QT, Tensor.Add(?1, ?2))
Reducer: Guard(?1: QT, Tensor.Add(?1, ?1))
###
> QT->Add(QTs)
QT->Add(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: QT, ?3: *1, Tensor.Add(?2, ?3)))
###
> QT->Add(U)
QT->Add(U) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Add(?1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
###
> QT->Add(V)
QT->Add(V) : i8[*,*]?
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Guard(?1: QT, Tensor.Add(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Add(R)
QT->Add(R) : i8[*,*]?
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Add(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Add(i4)
QT->Add(i4) : i8[*,*]?
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Add(?1, Error(ErrBadType_Src_Dst)))
###
> T->Sub(T)
T->Sub(T) : i8[*,*]
Binder : Tensor.Sub(T, T)
###
> T->Sub(Ts)
T->Sub(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Sub(T, *1))
###
> T->Sub(QT)
T->Sub(QT) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Sub(T, ?1))
###
> T->Sub(QTs)
T->Sub(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: *1, Tensor.Sub(T, ?2)))
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> T->Sub(V)
T->Sub(V) : i8[*,*]
*** Error: (7,8) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Sub(T, Error(ErrBadType_Src_Dst))
###
> T->Sub(R)
T->Sub(R) : i8[*,*]
*** Error: (7,8) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Tensor.Sub(T, Error(ErrBadType_Src_Dst))
###
> T->Sub(i4)
T->Sub(i4) : i8[*,*]
*** Error: (7,9) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Sub(T, Error(ErrBadType_Src_Dst))
###
> Ts->Sub(T)
Ts->Sub(T) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Sub(*1, T))
###
> Ts->Sub(Ts)
Ts->Sub(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, *2: Ts, Tensor.Sub(*1, *2))
Reducer: ForEach(*1: Ts, Tensor.Sub(*1, *1))
###
> Ts->Sub(QT)
Ts->Sub(QT) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Sub(*1, ?2)))
###
> Ts->Sub(QTs)
Ts->Sub(QTs) : i8[*,*]?*
Binder : ForEach(*1: Ts, *2: QTs, Guard(?3: *2, Tensor.Sub(*1, ?3)))
###
> Ts->Sub(U)
Ts->Sub(U) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Sub(*1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
Hoister: With(!2: Tensor.ForEachLazy(@1: U, Num<i8>(@1)), ForEach(*3: Ts, Tensor.Sub(*3, !2)))
###
> Ts->Sub(V)
Ts->Sub(V) : i8[*,*]*
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : ForEach(*1: Ts, Tensor.Sub(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Sub(R)
Ts->Sub(R) : i8[*,*]*
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Sub(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Sub(i4)
Ts->Sub(i4) : i8[*,*]*
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Sub(*1, Error(ErrBadType_Src_Dst)))
###
> QT->Sub(T)
QT->Sub(T) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Sub(?1, T))
###
> QT->Sub(Ts)
QT->Sub(Ts) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Sub(?2, *1)))
###
> QT->Sub(QT)
QT->Sub(QT) : i8[*,*]?
Binder : Guard(?1: QT, ?2: QT, Tensor.Sub(?1, ?2))
Reducer: Guard(?1: QT, Tensor.Sub(?1, ?1))
###
> QT->Sub(QTs)
QT->Sub(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: QT, ?3: *1, Tensor.Sub(?2, ?3)))
###
> QT->Sub(U)
QT->Sub(U) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Sub(?1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
###
> QT->Sub(V)
QT->Sub(V) : i8[*,*]?
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Guard(?1: QT, Tensor.Sub(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Sub(R)
QT->Sub(R) : i8[*,*]?
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Sub(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Sub(i4)
QT->Sub(i4) : i8[*,*]?
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Sub(?1, Error(ErrBadType_Src_Dst)))
###
> T->Mul(T)
T->Mul(T) : i8[*,*]
Binder : Tensor.Mul(T, T)
###
> T->Mul(Ts)
T->Mul(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Mul(T, *1))
###
> T->Mul(QT)
T->Mul(QT) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Mul(T, ?1))
###
> T->Mul(QTs)
T->Mul(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: *1, Tensor.Mul(T, ?2)))
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> T->Mul(V)
T->Mul(V) : i8[*,*]
*** Error: (7,8) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Mul(T, Error(ErrBadType_Src_Dst))
###
> T->Mul(R)
T->Mul(R) : i8[*,*]
*** Error: (7,8) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Tensor.Mul(T, Error(ErrBadType_Src_Dst))
###
> T->Mul(i4)
T->Mul(i4) : i8[*,*]
*** Error: (7,9) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Mul(T, Error(ErrBadType_Src_Dst))
###
> Ts->Mul(T)
Ts->Mul(T) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Mul(*1, T))
###
> Ts->Mul(Ts)
Ts->Mul(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, *2: Ts, Tensor.Mul(*1, *2))
Reducer: ForEach(*1: Ts, Tensor.Mul(*1, *1))
###
> Ts->Mul(QT)
Ts->Mul(QT) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Mul(*1, ?2)))
###
> Ts->Mul(QTs)
Ts->Mul(QTs) : i8[*,*]?*
Binder : ForEach(*1: Ts, *2: QTs, Guard(?3: *2, Tensor.Mul(*1, ?3)))
###
> Ts->Mul(U)
Ts->Mul(U) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Mul(*1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
Hoister: With(!2: Tensor.ForEachLazy(@1: U, Num<i8>(@1)), ForEach(*3: Ts, Tensor.Mul(*3, !2)))
###
> Ts->Mul(V)
Ts->Mul(V) : i8[*,*]*
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : ForEach(*1: Ts, Tensor.Mul(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Mul(R)
Ts->Mul(R) : i8[*,*]*
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Mul(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Mul(i4)
Ts->Mul(i4) : i8[*,*]*
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Mul(*1, Error(ErrBadType_Src_Dst)))
###
> QT->Mul(T)
QT->Mul(T) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Mul(?1, T))
###
> QT->Mul(Ts)
QT->Mul(Ts) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Mul(?2, *1)))
###
> QT->Mul(QT)
QT->Mul(QT) : i8[*,*]?
Binder : Guard(?1: QT, ?2: QT, Tensor.Mul(?1, ?2))
Reducer: Guard(?1: QT, Tensor.Mul(?1, ?1))
###
> QT->Mul(QTs)
QT->Mul(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: QT, ?3: *1, Tensor.Mul(?2, ?3)))
###
> QT->Mul(U)
QT->Mul(U) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Mul(?1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
###
> QT->Mul(V)
QT->Mul(V) : i8[*,*]?
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Guard(?1: QT, Tensor.Mul(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Mul(R)
QT->Mul(R) : i8[*,*]?
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Mul(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Mul(i4)
QT->Mul(i4) : i8[*,*]?
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Mul(?1, Error(ErrBadType_Src_Dst)))
###
> T->Min(T)
T->Min(T) : i8[*,*]
Binder : Tensor.Min(T, T)
###
> T->Min(Ts)
T->Min(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Min(T, *1))
###
> T->Min(QT)
T->Min(QT) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Min(T, ?1))
###
> T->Min(QTs)
T->Min(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: *1, Tensor.Min(T, ?2)))
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> T->Min(V)
T->Min(V) : i8[*,*]
*** Error: (7,8) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Min(T, Error(ErrBadType_Src_Dst))
###
> T->Min(R)
T->Min(R) : i8[*,*]
*** Error: (7,8) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Tensor.Min(T, Error(ErrBadType_Src_Dst))
###
> T->Min(i4)
T->Min(i4) : i8[*,*]
*** Error: (7,9) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Min(T, Error(ErrBadType_Src_Dst))
###
> Ts->Min(T)
Ts->Min(T) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Min(*1, T))
###
> Ts->Min(Ts)
Ts->Min(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, *2: Ts, Tensor.Min(*1, *2))
Reducer: ForEach(*1: Ts, Tensor.Min(*1, *1))
###
> Ts->Min(QT)
Ts->Min(QT) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Min(*1, ?2)))
###
> Ts->Min(QTs)
Ts->Min(QTs) : i8[*,*]?*
Binder : ForEach(*1: Ts, *2: QTs, Guard(?3: *2, Tensor.Min(*1, ?3)))
###
> Ts->Min(U)
Ts->Min(U) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Min(*1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
Hoister: With(!2: Tensor.ForEachLazy(@1: U, Num<i8>(@1)), ForEach(*3: Ts, Tensor.Min(*3, !2)))
###
> Ts->Min(V)
Ts->Min(V) : i8[*,*]*
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : ForEach(*1: Ts, Tensor.Min(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Min(R)
Ts->Min(R) : i8[*,*]*
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Min(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Min(i4)
Ts->Min(i4) : i8[*,*]*
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Min(*1, Error(ErrBadType_Src_Dst)))
###
> QT->Min(T)
QT->Min(T) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Min(?1, T))
###
> QT->Min(Ts)
QT->Min(Ts) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Min(?2, *1)))
###
> QT->Min(QT)
QT->Min(QT) : i8[*,*]?
Binder : Guard(?1: QT, ?2: QT, Tensor.Min(?1, ?2))
Reducer: Guard(?1: QT, Tensor.Min(?1, ?1))
###
> QT->Min(QTs)
QT->Min(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: QT, ?3: *1, Tensor.Min(?2, ?3)))
###
> QT->Min(U)
QT->Min(U) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Min(?1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
###
> QT->Min(V)
QT->Min(V) : i8[*,*]?
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Guard(?1: QT, Tensor.Min(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Min(R)
QT->Min(R) : i8[*,*]?
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Min(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Min(i4)
QT->Min(i4) : i8[*,*]?
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Min(?1, Error(ErrBadType_Src_Dst)))
###
> T->Max(T)
T->Max(T) : i8[*,*]
Binder : Tensor.Max(T, T)
###
> T->Max(Ts)
T->Max(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Max(T, *1))
###
> T->Max(QT)
T->Max(QT) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Max(T, ?1))
###
> T->Max(QTs)
T->Max(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: *1, Tensor.Max(T, ?2)))
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> T->Max(V)
T->Max(V) : i8[*,*]
*** Error: (7,8) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Max(T, Error(ErrBadType_Src_Dst))
###
> T->Max(R)
T->Max(R) : i8[*,*]
*** Error: (7,8) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Tensor.Max(T, Error(ErrBadType_Src_Dst))
###
> T->Max(i4)
T->Max(i4) : i8[*,*]
*** Error: (7,9) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Max(T, Error(ErrBadType_Src_Dst))
###
> Ts->Max(T)
Ts->Max(T) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Max(*1, T))
###
> Ts->Max(Ts)
Ts->Max(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, *2: Ts, Tensor.Max(*1, *2))
Reducer: ForEach(*1: Ts, Tensor.Max(*1, *1))
###
> Ts->Max(QT)
Ts->Max(QT) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Max(*1, ?2)))
###
> Ts->Max(QTs)
Ts->Max(QTs) : i8[*,*]?*
Binder : ForEach(*1: Ts, *2: QTs, Guard(?3: *2, Tensor.Max(*1, ?3)))
###
> Ts->Max(U)
Ts->Max(U) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Max(*1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
Hoister: With(!2: Tensor.ForEachLazy(@1: U, Num<i8>(@1)), ForEach(*3: Ts, Tensor.Max(*3, !2)))
###
> Ts->Max(V)
Ts->Max(V) : i8[*,*]*
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : ForEach(*1: Ts, Tensor.Max(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Max(R)
Ts->Max(R) : i8[*,*]*
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Max(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Max(i4)
Ts->Max(i4) : i8[*,*]*
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Max(*1, Error(ErrBadType_Src_Dst)))
###
> QT->Max(T)
QT->Max(T) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Max(?1, T))
###
> QT->Max(Ts)
QT->Max(Ts) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Max(?2, *1)))
###
> QT->Max(QT)
QT->Max(QT) : i8[*,*]?
Binder : Guard(?1: QT, ?2: QT, Tensor.Max(?1, ?2))
Reducer: Guard(?1: QT, Tensor.Max(?1, ?1))
###
> QT->Max(QTs)
QT->Max(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: QT, ?3: *1, Tensor.Max(?2, ?3)))
###
> QT->Max(U)
QT->Max(U) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Max(?1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
###
> QT->Max(V)
QT->Max(V) : i8[*,*]?
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Guard(?1: QT, Tensor.Max(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Max(R)
QT->Max(R) : i8[*,*]?
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Max(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Max(i4)
QT->Max(i4) : i8[*,*]?
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Max(?1, Error(ErrBadType_Src_Dst)))
###
> T->Div(T)
T->Div(T) : i8[*,*]
Binder : Tensor.Div(T, T)
###
> T->Div(Ts)
T->Div(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Div(T, *1))
###
> T->Div(QT)
T->Div(QT) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Div(T, ?1))
###
> T->Div(QTs)
T->Div(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: *1, Tensor.Div(T, ?2)))
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> T->Div(V)
T->Div(V) : i8[*,*]
*** Error: (7,8) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Tensor.Div(T, Error(ErrBadType_Src_Dst))
###
> T->Div(R)
T->Div(R) : i8[*,*]
*** Error: (7,8) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Tensor.Div(T, Error(ErrBadType_Src_Dst))
###
> T->Div(i4)
T->Div(i4) : i8[*,*]
*** Error: (7,9) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Div(T, Error(ErrBadType_Src_Dst))
###
> Ts->Div(T)
Ts->Div(T) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Div(*1, T))
###
> Ts->Div(Ts)
Ts->Div(Ts) : i8[*,*]*
Binder : ForEach(*1: Ts, *2: Ts, Tensor.Div(*1, *2))
Reducer: ForEach(*1: Ts, Tensor.Div(*1, *1))
###
> Ts->Div(QT)
Ts->Div(QT) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Div(*1, ?2)))
###
> Ts->Div(QTs)
Ts->Div(QTs) : i8[*,*]?*
Binder : ForEach(*1: Ts, *2: QTs, Guard(?3: *2, Tensor.Div(*1, ?3)))
###
> Ts->Div(U)
Ts->Div(U) : i8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Div(*1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
Hoister: With(!2: Tensor.ForEachLazy(@1: U, Num<i8>(@1)), ForEach(*3: Ts, Tensor.Div(*3, !2)))
###
> Ts->Div(V)
Ts->Div(V) : i8[*,*]*
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : ForEach(*1: Ts, Tensor.Div(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Div(R)
Ts->Div(R) : i8[*,*]*
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Div(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Div(i4)
Ts->Div(i4) : i8[*,*]*
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : ForEach(*1: Ts, Tensor.Div(*1, Error(ErrBadType_Src_Dst)))
###
> QT->Div(T)
QT->Div(T) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Div(?1, T))
###
> QT->Div(Ts)
QT->Div(Ts) : i8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Div(?2, *1)))
###
> QT->Div(QT)
QT->Div(QT) : i8[*,*]?
Binder : Guard(?1: QT, ?2: QT, Tensor.Div(?1, ?2))
Reducer: Guard(?1: QT, Tensor.Div(?1, ?1))
###
> QT->Div(QTs)
QT->Div(QTs) : i8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: QT, ?3: *1, Tensor.Div(?2, ?3)))
###
> QT->Div(U)
QT->Div(U) : i8[*,*]?
Binder : Guard(?1: QT, Tensor.Div(?1, Tensor.ForEachLazy(@2: U, Num<i8>(@2))))
###
> QT->Div(V)
QT->Div(V) : i8[*,*]?
*** Error: (8,9) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'i8[*,*]'
Binder : Guard(?1: QT, Tensor.Div(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Div(R)
QT->Div(R) : i8[*,*]?
*** Error: (8,9) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Div(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Div(i4)
QT->Div(i4) : i8[*,*]?
*** Error: (8,10) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Guard(?1: QT, Tensor.Div(?1, Error(ErrBadType_Src_Dst)))
###
> Tensor.Add(i4,T)
Tensor.Add(i4, T) : i8[*,*]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Add(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Sub(i4,T)
Tensor.Sub(i4, T) : i8[*,*]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Sub(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Mul(i4,T)
Tensor.Mul(i4, T) : i8[*,*]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Mul(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Min(i4,T)
Tensor.Min(i4, T) : i8[*,*]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Min(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Max(i4,T)
Tensor.Max(i4, T) : i8[*,*]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Max(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Div(i4,T)
Tensor.Div(i4, T) : i8[*,*]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i8[]'
Binder : Tensor.Div(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Add(i4,i4)
Tensor.Add(i4, i4) : i4[]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
Binder : Tensor.Add(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Tensor.Sub(i4,i4)
Tensor.Sub(i4, i4) : i4[]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
Binder : Tensor.Sub(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Tensor.Mul(i4,i4)
Tensor.Mul(i4, i4) : i4[]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
Binder : Tensor.Mul(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Tensor.Min(i4,i4)
Tensor.Min(i4, i4) : i4[]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
Binder : Tensor.Min(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Tensor.Max(i4,i4)
Tensor.Max(i4, i4) : i4[]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
Binder : Tensor.Max(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Tensor.Div(i4,i4)
Tensor.Div(i4, i4) : i4[]
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'i4[]'
Binder : Tensor.Div(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###

**** New globals: {QT:r8[*,*]?, QTs:r8[*,*]?*, R:{A:i4}, T:r8[*,*], Ts:r8[*,*]*, U:r4[*,*], V:s[*,*], i4:i4, r4:r4}

> T->Divide(T)
T->Divide(T) : r8[*,*]
Binder : Tensor.Divide(T, T)
###
> T->Divide(Ts)
T->Divide(Ts) : r8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Divide(T, *1))
###
> T->Divide(QT)
T->Divide(QT) : r8[*,*]?
Binder : Guard(?1: QT, Tensor.Divide(T, ?1))
###
> T->Divide(QTs)
T->Divide(QTs) : r8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: *1, Tensor.Divide(T, ?2)))
###
> T->Divide(U)
T->Divide(U) : r8[*,*]
Binder : Tensor.Divide(T, Tensor.ForEachLazy(@1: U, Num<r8>(@1)))
###
> T->Divide(V)
T->Divide(V) : r8[*,*]
*** Error: (10,11) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Tensor.Divide(T, Error(ErrBadType_Src_Dst))
###
> T->Divide(R)
T->Divide(R) : r8[*,*]
*** Error: (10,11) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'r8[]'
Binder : Tensor.Divide(T, Error(ErrBadType_Src_Dst))
###
> T->Divide(r4)
T->Divide(r4) : r8[*,*]
*** Error: (10,12) Node: r4, Message: Invalid operand type: cannot convert type 'r4' to 'r8[]'
Binder : Tensor.Divide(T, Error(ErrBadType_Src_Dst))
###
> T->Divide(i4)
T->Divide(i4) : r8[*,*]
*** Error: (10,12) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'r8[]'
Binder : Tensor.Divide(T, Error(ErrBadType_Src_Dst))
###
> Ts->Divide(T)
Ts->Divide(T) : r8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Divide(*1, T))
###
> Ts->Divide(Ts)
Ts->Divide(Ts) : r8[*,*]*
Binder : ForEach(*1: Ts, *2: Ts, Tensor.Divide(*1, *2))
Reducer: ForEach(*1: Ts, Tensor.Divide(*1, *1))
###
> Ts->Divide(QT)
Ts->Divide(QT) : r8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Divide(*1, ?2)))
###
> Ts->Divide(QTs)
Ts->Divide(QTs) : r8[*,*]?*
Binder : ForEach(*1: Ts, *2: QTs, Guard(?3: *2, Tensor.Divide(*1, ?3)))
###
> Ts->Divide(U)
Ts->Divide(U) : r8[*,*]*
Binder : ForEach(*1: Ts, Tensor.Divide(*1, Tensor.ForEachLazy(@2: U, Num<r8>(@2))))
Hoister: With(!2: Tensor.ForEachLazy(@1: U, Num<r8>(@1)), ForEach(*3: Ts, Tensor.Divide(*3, !2)))
###
> Ts->Divide(V)
Ts->Divide(V) : r8[*,*]*
*** Error: (11,12) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : ForEach(*1: Ts, Tensor.Divide(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Divide(R)
Ts->Divide(R) : r8[*,*]*
*** Error: (11,12) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'r8[]'
Binder : ForEach(*1: Ts, Tensor.Divide(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Divide(r4)
Ts->Divide(r4) : r8[*,*]*
*** Error: (11,13) Node: r4, Message: Invalid operand type: cannot convert type 'r4' to 'r8[]'
Binder : ForEach(*1: Ts, Tensor.Divide(*1, Error(ErrBadType_Src_Dst)))
###
> Ts->Divide(i4)
Ts->Divide(i4) : r8[*,*]*
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'r8[]'
Binder : ForEach(*1: Ts, Tensor.Divide(*1, Error(ErrBadType_Src_Dst)))
###
> QT->Divide(T)
QT->Divide(T) : r8[*,*]?
Binder : Guard(?1: QT, Tensor.Divide(?1, T))
###
> QT->Divide(Ts)
QT->Divide(Ts) : r8[*,*]?*
Binder : ForEach(*1: Ts, Guard(?2: QT, Tensor.Divide(?2, *1)))
###
> QT->Divide(QT)
QT->Divide(QT) : r8[*,*]?
Binder : Guard(?1: QT, ?2: QT, Tensor.Divide(?1, ?2))
Reducer: Guard(?1: QT, Tensor.Divide(?1, ?1))
###
> QT->Divide(QTs)
QT->Divide(QTs) : r8[*,*]?*
Binder : ForEach(*1: QTs, Guard(?2: QT, ?3: *1, Tensor.Divide(?2, ?3)))
###
> QT->Divide(U)
QT->Divide(U) : r8[*,*]?
Binder : Guard(?1: QT, Tensor.Divide(?1, Tensor.ForEachLazy(@2: U, Num<r8>(@2))))
###
> QT->Divide(V)
QT->Divide(V) : r8[*,*]?
*** Error: (11,12) Node: V, Message: Invalid operand type: cannot convert type 's[*,*]' to 'r8[*,*]'
Binder : Guard(?1: QT, Tensor.Divide(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Divide(R)
QT->Divide(R) : r8[*,*]?
*** Error: (11,12) Node: R, Message: Invalid operand type: cannot convert type '{A:i4}' to 'r8[]'
Binder : Guard(?1: QT, Tensor.Divide(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Divide(r4)
QT->Divide(r4) : r8[*,*]?
*** Error: (11,13) Node: r4, Message: Invalid operand type: cannot convert type 'r4' to 'r8[]'
Binder : Guard(?1: QT, Tensor.Divide(?1, Error(ErrBadType_Src_Dst)))
###
> QT->Divide(i4)
QT->Divide(i4) : r8[*,*]?
*** Error: (11,13) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'r8[]'
Binder : Guard(?1: QT, Tensor.Divide(?1, Error(ErrBadType_Src_Dst)))
###
> Tensor.Divide(i4, T)
Tensor.Divide(i4, T) : r8[*,*]
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'r8[]'
Binder : Tensor.Divide(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Divide(r4, T)
Tensor.Divide(r4, T) : r8[*,*]
*** Error: (14,16) Node: r4, Message: Invalid operand type: cannot convert type 'r4' to 'r8[]'
Binder : Tensor.Divide(Error(ErrBadType_Src_Dst), T)
###
> Tensor.Divide(i4, i4)
Tensor.Divide(i4, i4) : r8[]
*** Error: (14,16) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'r8[]'
*** Error: (18,20) Node: i4, Message: Invalid operand type: cannot convert type 'i4' to 'r8[]'
Binder : Tensor.Divide(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Tensor.Divide(r4, r4)
Tensor.Divide(r4, r4) : r4[]
*** Error: (14,16) Node: r4, Message: Invalid operand type: cannot convert type 'r4' to 'r4[]'
*** Error: (18,20) Node: r4, Message: Invalid operand type: cannot convert type 'r4' to 'r4[]'
Binder : Tensor.Divide(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###

**** New globals: {Ti1:i1[*,*], Ti2:i2[*,*], Ti4:i4[*,*], Ti8:i8[*,*], Tr4:r4[*,*], Tr8:r8[*,*], Tu1:u1[*,*], Tu2:u2[*,*], Tu4:u4[*,*], Tu8:u8[*,*]}

> Ti1->Div(Ti1)
Ti1->Div(Ti1) : i1[*,*]
Binder : Tensor.Div(Ti1, Ti1)
###
> Ti2->Div(Ti2)
Ti2->Div(Ti2) : i2[*,*]
Binder : Tensor.Div(Ti2, Ti2)
###
> Ti4->Div(Ti4)
Ti4->Div(Ti4) : i4[*,*]
Binder : Tensor.Div(Ti4, Ti4)
###
> Ti8->Div(Ti8)
Ti8->Div(Ti8) : i8[*,*]
Binder : Tensor.Div(Ti8, Ti8)
###
> Tu1->Div(Tu1)
Tu1->Div(Tu1) : u1[*,*]
Binder : Tensor.Div(Tu1, Tu1)
###
> Tu2->Div(Tu2)
Tu2->Div(Tu2) : u2[*,*]
Binder : Tensor.Div(Tu2, Tu2)
###
> Tu4->Div(Tu4)
Tu4->Div(Tu4) : u4[*,*]
Binder : Tensor.Div(Tu4, Tu4)
###
> Tu8->Div(Tu8)
Tu8->Div(Tu8) : u8[*,*]
Binder : Tensor.Div(Tu8, Tu8)
###
> Tr4->Div(Tr4)
Tr4->Div(Tr4) : i8[*,*]
*** Error: (0,3) Node: Tr4, Message: Invalid operand type: cannot convert type 'r4[*,*]' to 'i8[*,*]'
*** Error: (9,12) Node: Tr4, Message: Invalid operand type: cannot convert type 'r4[*,*]' to 'i8[*,*]'
Binder : Tensor.Div(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Tr8->Div(Tr8)
Tr8->Div(Tr8) : i8[*,*]
*** Error: (0,3) Node: Tr8, Message: Invalid operand type: cannot convert type 'r8[*,*]' to 'i8[*,*]'
*** Error: (9,12) Node: Tr8, Message: Invalid operand type: cannot convert type 'r8[*,*]' to 'i8[*,*]'
Binder : Tensor.Div(Error(ErrBadType_Src_Dst), Error(ErrBadType_Src_Dst))
###
> Ti1->Divide(Ti1)
Ti1->Divide(Ti1) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Ti1, Num<r8>(@1)), Tensor.ForEachLazy(@2: Ti1, Num<r8>(@2)))
###
> Ti2->Divide(Ti2)
Ti2->Divide(Ti2) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Ti2, Num<r8>(@1)), Tensor.ForEachLazy(@2: Ti2, Num<r8>(@2)))
###
> Ti4->Divide(Ti4)
Ti4->Divide(Ti4) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Ti4, Num<r8>(@1)), Tensor.ForEachLazy(@2: Ti4, Num<r8>(@2)))
###
> Ti8->Divide(Ti8)
Ti8->Divide(Ti8) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Ti8, Num<r8>(@1)), Tensor.ForEachLazy(@2: Ti8, Num<r8>(@2)))
###
> Tu1->Divide(Tu1)
Tu1->Divide(Tu1) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Tu1, Num<r8>(@1)), Tensor.ForEachLazy(@2: Tu1, Num<r8>(@2)))
###
> Tu2->Divide(Tu2)
Tu2->Divide(Tu2) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Tu2, Num<r8>(@1)), Tensor.ForEachLazy(@2: Tu2, Num<r8>(@2)))
###
> Tu4->Divide(Tu4)
Tu4->Divide(Tu4) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Tu4, Num<r8>(@1)), Tensor.ForEachLazy(@2: Tu4, Num<r8>(@2)))
###
> Tu8->Divide(Tu8)
Tu8->Divide(Tu8) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: Tu8, Num<r8>(@1)), Tensor.ForEachLazy(@2: Tu8, Num<r8>(@2)))
###
> Tr4->Divide(Tr4)
Tr4->Divide(Tr4) : r4[*,*]
Binder : Tensor.Divide(Tr4, Tr4)
###
> Tr8->Divide(Tr8)
Tr8->Divide(Tr8) : r8[*,*]
Binder : Tensor.Divide(Tr8, Tr8)
###

**** New globals: {T:i8[*,*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:r4[*,*], U:r4[*,*]}

> T->Divide(U)
T->Divide(U) : r4[*,*]
Binder : Tensor.Divide(T, U)
###
> U->Divide(T)
U->Divide(T) : r4[*,*]
Binder : Tensor.Divide(U, T)
###

**** New globals: {T:i4[*,*,*], U:i4[*,*,*]}

> T->Add(U)
T->Add(U) : i4[*,*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i4[*,*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i4[*,*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i4[*,*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i4[*,*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i4[*,*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i4[*,*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i4[*,*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i4[*,*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i4[*,*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i4[*,*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i4[*,*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:r4[*,*,*], U:r4[*,*,*]}

> T->Divide(U)
T->Divide(U) : r4[*,*,*]
Binder : Tensor.Divide(T, U)
###
> U->Divide(T)
U->Divide(T) : r4[*,*,*]
Binder : Tensor.Divide(U, T)
###

**** New globals: {T:i8[*,*], U:i4[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(Tensor.ForEachLazy(@1: U, Num<i8>(@1)), T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(Tensor.ForEachLazy(@1: U, Num<i8>(@1)), T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(Tensor.ForEachLazy(@1: U, Num<i8>(@1)), T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(Tensor.ForEachLazy(@1: U, Num<i8>(@1)), T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(Tensor.ForEachLazy(@1: U, Num<i8>(@1)), T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, Tensor.ForEachLazy(@1: U, Num<i8>(@1)))
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(Tensor.ForEachLazy(@1: U, Num<i8>(@1)), T)
###

**** New globals: {T:r8[*,*], U:r4[*,*]}

> T->Divide(U)
T->Divide(U) : r8[*,*]
Binder : Tensor.Divide(T, Tensor.ForEachLazy(@1: U, Num<r8>(@1)))
###
> U->Divide(T)
U->Divide(T) : r8[*,*]
Binder : Tensor.Divide(Tensor.ForEachLazy(@1: U, Num<r8>(@1)), T)
###

**** New globals: {T:i8[*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*], U:i8[*,*,*]}

> T->Add(U)
T->Add(U) : i8[*,*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*,*]}

> T->Add(U)
T->Add(U) : i8[*,*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*,*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*,*]}

> T->Add(U)
T->Add(U) : i8[*,*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*,*]}

> T->Add(U)
T->Add(U) : i8[*,*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*,*], U:i8[*,*,*]}

> T->Add(U)
T->Add(U) : i8[*,*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[*], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###

**** New globals: {T:i8[], U:i8[*,*]}

> T->Add(U)
T->Add(U) : i8[*,*]
Binder : Tensor.Add(T, U)
###
> U->Add(T)
U->Add(T) : i8[*,*]
Binder : Tensor.Add(U, T)
###
> T->Sub(U)
T->Sub(U) : i8[*,*]
Binder : Tensor.Sub(T, U)
###
> U->Sub(T)
U->Sub(T) : i8[*,*]
Binder : Tensor.Sub(U, T)
###
> T->Mul(U)
T->Mul(U) : i8[*,*]
Binder : Tensor.Mul(T, U)
###
> U->Mul(T)
U->Mul(T) : i8[*,*]
Binder : Tensor.Mul(U, T)
###
> T->Min(U)
T->Min(U) : i8[*,*]
Binder : Tensor.Min(T, U)
###
> U->Min(T)
U->Min(T) : i8[*,*]
Binder : Tensor.Min(U, T)
###
> T->Max(U)
T->Max(U) : i8[*,*]
Binder : Tensor.Max(T, U)
###
> U->Max(T)
U->Max(T) : i8[*,*]
Binder : Tensor.Max(U, T)
###
> T->Div(U)
T->Div(U) : i8[*,*]
Binder : Tensor.Div(T, U)
###
> U->Div(T)
U->Div(T) : i8[*,*]
Binder : Tensor.Div(U, T)
###
