**** New globals: {B:(b, b), I8:i8, N:r8, R:r8, X:i2, Y:i2, Z:i2, b:(b, b)?, g:g, n:r8?, o:o, s:s}

> -0d // Should be -0.
-0 : r8
Binder : -0
###
> 0d - 0d // Should be +0.
0 - 0 : r8
Binder : Add(0, [-] 0)
Reducer: 0
###
> -(0d + 0d) // Should be -0.
-(0 + 0) : r8
Binder : Add([-] 0, [-] 0)
Reducer: -0
###
> -0d + R // Leading constant should be -0.
-0 + R : r8
Binder : Add(-0, R)
###
> 0d - 0d + R // Leading constant should +0.
0 - 0 + R : r8
Binder : Add(0, [-] 0, R)
Reducer: Add(0, R)
###
> -(0d + 0d) + R // Leading constant should -0.
-(0 + 0) + R : r8
Binder : Add([-] 0, [-] 0, R)
Reducer: Add(-0, R)
###
> X + Y
X + Y : i8
Binder : Add(Num<i8>(X), Num<i8>(Y))
###
> X - Y
X - Y : i8
Binder : Add(Num<i8>(X), [-] Num<i8>(Y))
###
> X * Y
X * Y : i8
Binder : Mul(Num<i8>(X), Num<i8>(Y))
###
> X / Y
X / Y : r8
Binder : Mul(Num<r8>(X), [/] Num<r8>(Y))
###
> X ^ Y
X^Y : i8
Binder : Power(Num<i8>(X), Num<i8>(Y))
###
> X ^ R
X^R : r8
Binder : Power(Num<r8>(X), R)
###
> R ^ Y
R^Y : r8
Binder : Power(R, Num<r8>(Y))
###
> X + Y + Z
X + Y + Z : i8
Binder : Add(Num<i8>(X), Num<i8>(Y), Num<i8>(Z))
###
> X + Y - Z
X + Y - Z : i8
Binder : Add(Num<i8>(X), Num<i8>(Y), [-] Num<i8>(Z))
###
> X + Y * Z
X + Y * Z : i8
Binder : Add(Num<i8>(X), Mul(Num<i8>(Y), Num<i8>(Z)))
###
> X + Y / Z
X + Y / Z : r8
Binder : Add(Num<r8>(X), Mul(Num<r8>(Y), [/] Num<r8>(Z)))
###
> X + Y ^ Z
X + Y^Z : i8
Binder : Add(Num<i8>(X), Power(Num<i8>(Y), Num<i8>(Z)))
###
> X - Y + Z
X - Y + Z : i8
Binder : Add(Num<i8>(X), [-] Num<i8>(Y), Num<i8>(Z))
###
> X - Y - Z
X - Y - Z : i8
Binder : Add(Num<i8>(X), [-] Num<i8>(Y), [-] Num<i8>(Z))
###
> X - Y * Z
X - Y * Z : i8
Binder : Add(Num<i8>(X), [-] Mul(Num<i8>(Y), Num<i8>(Z)))
###
> X - Y / Z
X - Y / Z : r8
Binder : Add(Num<r8>(X), [-] Mul(Num<r8>(Y), [/] Num<r8>(Z)))
###
> X - Y ^ Z
X - Y^Z : i8
Binder : Add(Num<i8>(X), [-] Power(Num<i8>(Y), Num<i8>(Z)))
###
> X * Y + Z
X * Y + Z : i8
Binder : Add(Mul(Num<i8>(X), Num<i8>(Y)), Num<i8>(Z))
###
> X * Y - Z
X * Y - Z : i8
Binder : Add(Mul(Num<i8>(X), Num<i8>(Y)), [-] Num<i8>(Z))
###
> X * Y * Z
X * Y * Z : i8
Binder : Mul(Num<i8>(X), Num<i8>(Y), Num<i8>(Z))
###
> X * Y / Z
X * Y / Z : r8
Binder : Mul(Num<r8>(Mul(Num<i8>(X), Num<i8>(Y))), [/] Num<r8>(Z))
###
> X * Y ^ Z
X * Y^Z : i8
Binder : Mul(Num<i8>(X), Power(Num<i8>(Y), Num<i8>(Z)))
###
> X / Y + Z
X / Y + Z : r8
Binder : Add(Mul(Num<r8>(X), [/] Num<r8>(Y)), Num<r8>(Z))
###
> X / Y - Z
X / Y - Z : r8
Binder : Add(Mul(Num<r8>(X), [/] Num<r8>(Y)), [-] Num<r8>(Z))
###
> X / Y * Z
X / Y * Z : r8
Binder : Mul(Num<r8>(X), [/] Num<r8>(Y), Num<r8>(Z))
###
> X / Y / Z
X / Y / Z : r8
Binder : Mul(Num<r8>(X), [/] Num<r8>(Y), [/] Num<r8>(Z))
###
> X / Y ^ Z
X / Y^Z : r8
Binder : Mul(Num<r8>(X), [/] Num<r8>(Power(Num<i8>(Y), Num<i8>(Z))))
###
> X ^ Y + Z
X^Y + Z : i8
Binder : Add(Power(Num<i8>(X), Num<i8>(Y)), Num<i8>(Z))
###
> X ^ Y - Z
X^Y - Z : i8
Binder : Add(Power(Num<i8>(X), Num<i8>(Y)), [-] Num<i8>(Z))
###
> X ^ Y * Z
X^Y * Z : i8
Binder : Mul(Power(Num<i8>(X), Num<i8>(Y)), Num<i8>(Z))
###
> X ^ Y / Z
X^Y / Z : r8
Binder : Mul(Num<r8>(Power(Num<i8>(X), Num<i8>(Y))), [/] Num<r8>(Z))
###
> X ^ Y ^ Z
X^Y^Z : i8
Binder : Power(Num<i8>(X), Power(Num<i8>(Y), Num<i8>(Z)))
###
> 5 + 4
5 + 4 : i8
Binder : Add(5, 4)
Reducer: 9
###
> 5 - 4
5 - 4 : i8
Binder : Add(5, [-] 4)
Reducer: 1
###
> 5 * 4
5 * 4 : i8
Binder : Mul(5, 4)
Reducer: 20
###
> 5 / 4
5 / 4 : r8
Binder : Mul(5, [/] 4)
Reducer: 1.25
###
> 5 ^ 4
5^4 : i8
Binder : Power(5, 4)
Reducer: 625
###
> 5 + 4 + 2
5 + 4 + 2 : i8
Binder : Add(5, 4, 2)
Reducer: 11
###
> 5 + 4 - 2
5 + 4 - 2 : i8
Binder : Add(5, 4, [-] 2)
Reducer: 7
###
> 5 + 4 * 2
5 + 4 * 2 : i8
Binder : Add(5, Mul(4, 2))
Reducer: 13
###
> 5 + 4 / 2
5 + 4 / 2 : r8
Binder : Add(5, Mul(4, [/] 2))
Reducer: 7
###
> 5 + 4 ^ 2
5 + 4^2 : i8
Binder : Add(5, Power(4, 2))
Reducer: 21
###
> 5 - 4 + 2
5 - 4 + 2 : i8
Binder : Add(5, [-] 4, 2)
Reducer: 3
###
> 5 - 4 - 2
5 - 4 - 2 : i8
Binder : Add(5, [-] 4, [-] 2)
Reducer: -1
###
> 5 - 4 * 2
5 - 4 * 2 : i8
Binder : Add(5, [-] Mul(4, 2))
Reducer: -3
###
> 5 - 4 / 2
5 - 4 / 2 : r8
Binder : Add(5, [-] Mul(4, [/] 2))
Reducer: 3
###
> 5 - 4 ^ 2
5 - 4^2 : i8
Binder : Add(5, [-] Power(4, 2))
Reducer: -11
###
> 5 * 4 + 2
5 * 4 + 2 : i8
Binder : Add(Mul(5, 4), 2)
Reducer: 22
###
> 5 * 4 - 2
5 * 4 - 2 : i8
Binder : Add(Mul(5, 4), [-] 2)
Reducer: 18
###
> 5 * 4 * 2
5 * 4 * 2 : i8
Binder : Mul(5, 4, 2)
Reducer: 40
###
> 5 * 4 / 2
5 * 4 / 2 : r8
Binder : Mul(Num<r8>(Mul(5, 4)), [/] 2)
Reducer: 10
###
> 5 * 4 ^ 2
5 * 4^2 : i8
Binder : Mul(5, Power(4, 2))
Reducer: 80
###
> 5 / 4 + 2
5 / 4 + 2 : r8
Binder : Add(Mul(5, [/] 4), 2)
Reducer: 3.25
###
> 5 / 4 - 2
5 / 4 - 2 : r8
Binder : Add(Mul(5, [/] 4), [-] 2)
Reducer: -0.75
###
> 5 / 4 * 2
5 / 4 * 2 : r8
Binder : Mul(5, [/] 4, 2)
Reducer: 2.5
###
> 5 / 4 / 2
5 / 4 / 2 : r8
Binder : Mul(5, [/] 4, [/] 2)
Reducer: 0.625
###
> 5 / 4 ^ 2
5 / 4^2 : r8
Binder : Mul(5, [/] Num<r8>(Power(4, 2)))
Reducer: 0.3125
###
> 5 ^ 4 + 2
5^4 + 2 : i8
Binder : Add(Power(5, 4), 2)
Reducer: 627
###
> 5 ^ 4 - 2
5^4 - 2 : i8
Binder : Add(Power(5, 4), [-] 2)
Reducer: 623
###
> 5 ^ 4 * 2
5^4 * 2 : i8
Binder : Mul(Power(5, 4), 2)
Reducer: 1250
###
> 5 ^ 4 / 2
5^4 / 2 : r8
Binder : Mul(Num<r8>(Power(5, 4)), [/] 2)
Reducer: 312.5
###
> 5 ^ 4 ^ 2
5^4^2 : i8
Binder : Power(5, Power(4, 2))
Reducer: 152587890625
###
> 5d ^ 4
5^4 : r8
Binder : Power(5, 4)
Reducer: 625
###
> 5 ^ 4d
5^4 : r8
Binder : Power(5, 4)
Reducer: 625
###
> 5 ^ -4
5^-4 : i8
Binder : Power(5, -4)
Reducer: 1
###
> X ^  0
X^0 : i8
Binder : Power(Num<i8>(X), 0)
Reducer: 1
###
> X ^ +1
X^+1 : i8
Binder : Power(Num<i8>(X), 1)
Reducer: Num<i8>(X)
###
> X ^ -1
X^-1 : i8
Binder : Power(Num<i8>(X), -1)
Reducer: 1
###
> R ^  0
R^0 : r8
Binder : Power(R, 0)
###
> R ^ +1
R^+1 : r8
Binder : Power(R, 1)
Reducer: R
###
> R ^ -1
R^-1 : r8
Binder : Power(R, -1)
###
> null + 4
null + 4 : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), 4))
Reducer: null
###
> null - 4
null - 4 : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), [-] 4))
Reducer: null
###
> null * 4
null * 4 : i8?
Binder : Guard(?1: null, Mul(Unit<i8>(?1), 4))
Reducer: null
###
> null / 4
null / 4 : r8?
Binder : Guard(?1: null, Mul(Unit<r8>(?1), [/] 4))
Reducer: null
###
> null ^ 4
null^4 : i8?
Binder : Guard(?1: null, Power(Unit<i8>(?1), 4))
Reducer: null
###
> null + 4 + 2
null + 4 + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(Unit<i8>(?1), 4)), Add(?2, 2))
Reducer: null
###
> null + 4 - 2
null + 4 - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(Unit<i8>(?1), 4)), Add(?2, [-] 2))
Reducer: null
###
> null + 4 * 2
null + 4 * 2 : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), Mul(4, 2)))
Reducer: null
###
> null + 4 / 2
null + 4 / 2 : r8?
Binder : Guard(?1: null, Add(Unit<r8>(?1), Mul(4, [/] 2)))
Reducer: null
###
> null + 4 ^ 2
null + 4^2 : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), Power(4, 2)))
Reducer: null
###
> null - 4 + 2
null - 4 + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(Unit<i8>(?1), [-] 4)), Add(?2, 2))
Reducer: null
###
> null - 4 - 2
null - 4 - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(Unit<i8>(?1), [-] 4)), Add(?2, [-] 2))
Reducer: null
###
> null - 4 * 2
null - 4 * 2 : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), [-] Mul(4, 2)))
Reducer: null
###
> null - 4 / 2
null - 4 / 2 : r8?
Binder : Guard(?1: null, Add(Unit<r8>(?1), [-] Mul(4, [/] 2)))
Reducer: null
###
> null - 4 ^ 2
null - 4^2 : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), [-] Power(4, 2)))
Reducer: null
###
> null * 4 + 2
null * 4 + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<i8>(?1), 4)), Add(?2, 2))
Reducer: null
###
> null * 4 - 2
null * 4 - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<i8>(?1), 4)), Add(?2, [-] 2))
Reducer: null
###
> null * 4 * 2
null * 4 * 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<i8>(?1), 4)), Mul(?2, 2))
Reducer: null
###
> null * 4 / 2
null * 4 / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<i8>(?1), 4)), Mul(Num<r8>(?2), [/] 2))
Reducer: null
###
> null * 4 ^ 2
null * 4^2 : i8?
Binder : Guard(?1: null, Mul(Unit<i8>(?1), Power(4, 2)))
Reducer: null
###
> null / 4 + 2
null / 4 + 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<r8>(?1), [/] 4)), Add(?2, 2))
Reducer: null
###
> null / 4 - 2
null / 4 - 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<r8>(?1), [/] 4)), Add(?2, [-] 2))
Reducer: null
###
> null / 4 * 2
null / 4 * 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<r8>(?1), [/] 4)), Mul(?2, 2))
Reducer: null
###
> null / 4 / 2
null / 4 / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<r8>(?1), [/] 4)), Mul(?2, [/] 2))
Reducer: null
###
> null / 4 ^ 2
null / 4^2 : r8?
Binder : Guard(?1: null, Mul(Unit<r8>(?1), [/] Num<r8>(Power(4, 2))))
Reducer: null
###
> null ^ 4 + 2
null^4 + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 4)), Add(?2, 2))
Reducer: null
###
> null ^ 4 - 2
null^4 - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 4)), Add(?2, [-] 2))
Reducer: null
###
> null ^ 4 * 2
null^4 * 2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 4)), Mul(?2, 2))
Reducer: null
###
> null ^ 4 / 2
null^4 / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 4)), Mul(Num<r8>(?2), [/] 2))
Reducer: null
###
> null ^ 4 ^ 2
null^4^2 : i8?
Binder : Guard(?1: null, Power(Unit<i8>(?1), Power(4, 2)))
Reducer: null
###
> 5 + null
5 + null : i8?
Binder : Guard(?1: null, Add(5, Unit<i8>(?1)))
Reducer: null
###
> 5 - null
5 - null : i8?
Binder : Guard(?1: null, Add(5, [-] Unit<i8>(?1)))
Reducer: null
###
> 5 * null
5 * null : i8?
Binder : Guard(?1: null, Mul(5, Unit<i8>(?1)))
Reducer: null
###
> 5 / null
5 / null : r8?
Binder : Guard(?1: null, Mul(5, [/] Unit<r8>(?1)))
Reducer: null
###
> 5 ^ null
5^null : i8?
Binder : Guard(?1: null, Power(5, Unit<u8>(?1)))
Reducer: null
###
> 5 + null + 2
5 + null + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(5, Unit<i8>(?1))), Add(?2, 2))
Reducer: null
###
> 5 + null - 2
5 + null - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(5, Unit<i8>(?1))), Add(?2, [-] 2))
Reducer: null
###
> 5 + null * 2
5 + null * 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<i8>(?1), 2)), Add(5, ?2))
Reducer: null
###
> 5 + null / 2
5 + null / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<r8>(?1), [/] 2)), Add(5, ?2))
Reducer: null
###
> 5 + null ^ 2
5 + null^2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 2)), Add(5, ?2))
Reducer: null
###
> 5 - null + 2
5 - null + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(5, [-] Unit<i8>(?1))), Add(?2, 2))
Reducer: null
###
> 5 - null - 2
5 - null - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Add(5, [-] Unit<i8>(?1))), Add(?2, [-] 2))
Reducer: null
###
> 5 - null * 2
5 - null * 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<i8>(?1), 2)), Add(5, [-] ?2))
Reducer: null
###
> 5 - null / 2
5 - null / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(Unit<r8>(?1), [/] 2)), Add(5, [-] ?2))
Reducer: null
###
> 5 - null ^ 2
5 - null^2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 2)), Add(5, [-] ?2))
Reducer: null
###
> 5 * null + 2
5 * null + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(5, Unit<i8>(?1))), Add(?2, 2))
Reducer: null
###
> 5 * null - 2
5 * null - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(5, Unit<i8>(?1))), Add(?2, [-] 2))
Reducer: null
###
> 5 * null * 2
5 * null * 2 : i8?
Binder : Guard(?2: Guard(?1: null, Mul(5, Unit<i8>(?1))), Mul(?2, 2))
Reducer: null
###
> 5 * null / 2
5 * null / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(5, Unit<i8>(?1))), Mul(Num<r8>(?2), [/] 2))
Reducer: null
###
> 5 * null ^ 2
5 * null^2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 2)), Mul(5, ?2))
Reducer: null
###
> 5 / null + 2
5 / null + 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(5, [/] Unit<r8>(?1))), Add(?2, 2))
Reducer: null
###
> 5 / null - 2
5 / null - 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(5, [/] Unit<r8>(?1))), Add(?2, [-] 2))
Reducer: null
###
> 5 / null * 2
5 / null * 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(5, [/] Unit<r8>(?1))), Mul(?2, 2))
Reducer: null
###
> 5 / null / 2
5 / null / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Mul(5, [/] Unit<r8>(?1))), Mul(?2, [/] 2))
Reducer: null
###
> 5 / null ^ 2
5 / null^2 : r8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 2)), Mul(5, [/] Num<r8>(?2)))
Reducer: null
###
> 5 ^ null + 2
5^null + 2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(5, Unit<u8>(?1))), Add(?2, 2))
Reducer: null
###
> 5 ^ null - 2
5^null - 2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(5, Unit<u8>(?1))), Add(?2, [-] 2))
Reducer: null
###
> 5 ^ null * 2
5^null * 2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(5, Unit<u8>(?1))), Mul(?2, 2))
Reducer: null
###
> 5 ^ null / 2
5^null / 2 : r8?
Binder : Guard(?2: Guard(?1: null, Power(5, Unit<u8>(?1))), Mul(Num<r8>(?2), [/] 2))
Reducer: null
###
> 5 ^ null ^ 2
5^null^2 : i8?
Binder : Guard(?2: Guard(?1: null, Power(Unit<i8>(?1), 2)), Power(5, ?2))
Reducer: null
###
> 5 + 4
5 + 4 : i8
Binder : Add(5, 4)
Reducer: 9
###
> 5 - 4
5 - 4 : i8
Binder : Add(5, [-] 4)
Reducer: 1
###
> 5 * 4
5 * 4 : i8
Binder : Mul(5, 4)
Reducer: 20
###
> 5 / 4
5 / 4 : r8
Binder : Mul(5, [/] 4)
Reducer: 1.25
###
> 5 ^ 4
5^4 : i8
Binder : Power(5, 4)
Reducer: 625
###
> 5 + 4 + null
5 + 4 + null : i8?
Binder : Guard(?1: null, Add(5, 4, Unit<i8>(?1)))
Reducer: null
###
> 5 + 4 - null
5 + 4 - null : i8?
Binder : Guard(?1: null, Add(5, 4, [-] Unit<i8>(?1)))
Reducer: null
###
> 5 + 4 * null
5 + 4 * null : i8?
Binder : Guard(?2: Guard(?1: null, Mul(4, Unit<i8>(?1))), Add(5, ?2))
Reducer: null
###
> 5 + 4 / null
5 + 4 / null : r8?
Binder : Guard(?2: Guard(?1: null, Mul(4, [/] Unit<r8>(?1))), Add(5, ?2))
Reducer: null
###
> 5 + 4 ^ null
5 + 4^null : i8?
Binder : Guard(?2: Guard(?1: null, Power(4, Unit<u8>(?1))), Add(5, ?2))
Reducer: null
###
> 5 - 4 + null
5 - 4 + null : i8?
Binder : Guard(?1: null, Add(5, [-] 4, Unit<i8>(?1)))
Reducer: null
###
> 5 - 4 - null
5 - 4 - null : i8?
Binder : Guard(?1: null, Add(5, [-] 4, [-] Unit<i8>(?1)))
Reducer: null
###
> 5 - 4 * null
5 - 4 * null : i8?
Binder : Guard(?2: Guard(?1: null, Mul(4, Unit<i8>(?1))), Add(5, [-] ?2))
Reducer: null
###
> 5 - 4 / null
5 - 4 / null : r8?
Binder : Guard(?2: Guard(?1: null, Mul(4, [/] Unit<r8>(?1))), Add(5, [-] ?2))
Reducer: null
###
> 5 - 4 ^ null
5 - 4^null : i8?
Binder : Guard(?2: Guard(?1: null, Power(4, Unit<u8>(?1))), Add(5, [-] ?2))
Reducer: null
###
> 5 * 4 + null
5 * 4 + null : i8?
Binder : Guard(?1: null, Add(Mul(5, 4), Unit<i8>(?1)))
Reducer: null
###
> 5 * 4 - null
5 * 4 - null : i8?
Binder : Guard(?1: null, Add(Mul(5, 4), [-] Unit<i8>(?1)))
Reducer: null
###
> 5 * 4 * null
5 * 4 * null : i8?
Binder : Guard(?1: null, Mul(5, 4, Unit<i8>(?1)))
Reducer: null
###
> 5 * 4 / null
5 * 4 / null : r8?
Binder : Guard(?1: null, Mul(Num<r8>(Mul(5, 4)), [/] Unit<r8>(?1)))
Reducer: null
###
> 5 * 4 ^ null
5 * 4^null : i8?
Binder : Guard(?2: Guard(?1: null, Power(4, Unit<u8>(?1))), Mul(5, ?2))
Reducer: null
###
> 5 / 4 + null
5 / 4 + null : r8?
Binder : Guard(?1: null, Add(Mul(5, [/] 4), Unit<r8>(?1)))
Reducer: null
###
> 5 / 4 - null
5 / 4 - null : r8?
Binder : Guard(?1: null, Add(Mul(5, [/] 4), [-] Unit<r8>(?1)))
Reducer: null
###
> 5 / 4 * null
5 / 4 * null : r8?
Binder : Guard(?1: null, Mul(5, [/] 4, Unit<r8>(?1)))
Reducer: null
###
> 5 / 4 / null
5 / 4 / null : r8?
Binder : Guard(?1: null, Mul(5, [/] 4, [/] Unit<r8>(?1)))
Reducer: null
###
> 5 / 4 ^ null
5 / 4^null : r8?
Binder : Guard(?2: Guard(?1: null, Power(4, Unit<u8>(?1))), Mul(5, [/] Num<r8>(?2)))
Reducer: null
###
> 5 ^ 4 + null
5^4 + null : i8?
Binder : Guard(?1: null, Add(Power(5, 4), Unit<i8>(?1)))
Reducer: null
###
> 5 ^ 4 - null
5^4 - null : i8?
Binder : Guard(?1: null, Add(Power(5, 4), [-] Unit<i8>(?1)))
Reducer: null
###
> 5 ^ 4 * null
5^4 * null : i8?
Binder : Guard(?1: null, Mul(Power(5, 4), Unit<i8>(?1)))
Reducer: null
###
> 5 ^ 4 / null
5^4 / null : r8?
Binder : Guard(?1: null, Mul(Num<r8>(Power(5, 4)), [/] Unit<r8>(?1)))
Reducer: null
###
> 5 ^ 4 ^ null
5^4^null : i8?
Binder : Guard(?2: Guard(?1: null, Power(4, Unit<u8>(?1))), Power(5, ?2))
Reducer: null
###
> 5 + 4
5 + 4 : i8
Binder : Add(5, 4)
Reducer: 9
###
> 5 - 4
5 - 4 : i8
Binder : Add(5, [-] 4)
Reducer: 1
###
> 5 * 4
5 * 4 : i8
Binder : Mul(5, 4)
Reducer: 20
###
> 5 / 4
5 / 4 : r8
Binder : Mul(5, [/] 4)
Reducer: 1.25
###
> 5 ^ 4
5^4 : i8
Binder : Power(5, 4)
Reducer: 625
###
> 5 + 4 + Z
5 + 4 + Z : i8
Binder : Add(5, 4, Num<i8>(Z))
Reducer: Add(Num<i8>(Z), 9)
###
> 5 + 4 - Z
5 + 4 - Z : i8
Binder : Add(5, 4, [-] Num<i8>(Z))
Reducer: Add([-] Num<i8>(Z), 9)
###
> 5 + 4 * Z
5 + 4 * Z : i8
Binder : Add(5, Mul(4, Num<i8>(Z)))
Reducer: Add(Mul(Num<i8>(Z), 4), 5)
###
> 5 + 4 / Z
5 + 4 / Z : r8
Binder : Add(5, Mul(4, [/] Num<r8>(Z)))
###
> 5 + 4 ^ Z
5 + 4^Z : i8
Binder : Add(5, Power(4, Num<i8>(Z)))
Reducer: Add(Power(4, Num<i8>(Z)), 5)
###
> 5 - 4 + Z
5 - 4 + Z : i8
Binder : Add(5, [-] 4, Num<i8>(Z))
Reducer: Add(Num<i8>(Z), 1)
###
> 5 - 4 - Z
5 - 4 - Z : i8
Binder : Add(5, [-] 4, [-] Num<i8>(Z))
Reducer: Add([-] Num<i8>(Z), 1)
###
> 5 - 4 * Z
5 - 4 * Z : i8
Binder : Add(5, [-] Mul(4, Num<i8>(Z)))
Reducer: Add([-] Mul(Num<i8>(Z), 4), 5)
###
> 5 - 4 / Z
5 - 4 / Z : r8
Binder : Add(5, [-] Mul(4, [/] Num<r8>(Z)))
###
> 5 - 4 ^ Z
5 - 4^Z : i8
Binder : Add(5, [-] Power(4, Num<i8>(Z)))
Reducer: Add([-] Power(4, Num<i8>(Z)), 5)
###
> 5 * 4 + Z
5 * 4 + Z : i8
Binder : Add(Mul(5, 4), Num<i8>(Z))
Reducer: Add(Num<i8>(Z), 20)
###
> 5 * 4 - Z
5 * 4 - Z : i8
Binder : Add(Mul(5, 4), [-] Num<i8>(Z))
Reducer: Add([-] Num<i8>(Z), 20)
###
> 5 * 4 * Z
5 * 4 * Z : i8
Binder : Mul(5, 4, Num<i8>(Z))
Reducer: Mul(Num<i8>(Z), 20)
###
> 5 * 4 / Z
5 * 4 / Z : r8
Binder : Mul(Num<r8>(Mul(5, 4)), [/] Num<r8>(Z))
Reducer: Mul(20, [/] Num<r8>(Z))
###
> 5 * 4 ^ Z
5 * 4^Z : i8
Binder : Mul(5, Power(4, Num<i8>(Z)))
Reducer: Mul(Power(4, Num<i8>(Z)), 5)
###
> 5 / 4 + Z
5 / 4 + Z : r8
Binder : Add(Mul(5, [/] 4), Num<r8>(Z))
Reducer: Add(1.25, Num<r8>(Z))
###
> 5 / 4 - Z
5 / 4 - Z : r8
Binder : Add(Mul(5, [/] 4), [-] Num<r8>(Z))
Reducer: Add(1.25, [-] Num<r8>(Z))
###
> 5 / 4 * Z
5 / 4 * Z : r8
Binder : Mul(5, [/] 4, Num<r8>(Z))
Reducer: Mul(1.25, Num<r8>(Z))
###
> 5 / 4 / Z
5 / 4 / Z : r8
Binder : Mul(5, [/] 4, [/] Num<r8>(Z))
Reducer: Mul(1.25, [/] Num<r8>(Z))
###
> 5 / 4 ^ Z
5 / 4^Z : r8
Binder : Mul(5, [/] Num<r8>(Power(4, Num<i8>(Z))))
###
> 5 ^ 4 + Z
5^4 + Z : i8
Binder : Add(Power(5, 4), Num<i8>(Z))
Reducer: Add(Num<i8>(Z), 625)
###
> 5 ^ 4 - Z
5^4 - Z : i8
Binder : Add(Power(5, 4), [-] Num<i8>(Z))
Reducer: Add([-] Num<i8>(Z), 625)
###
> 5 ^ 4 * Z
5^4 * Z : i8
Binder : Mul(Power(5, 4), Num<i8>(Z))
Reducer: Mul(Num<i8>(Z), 625)
###
> 5 ^ 4 / Z
5^4 / Z : r8
Binder : Mul(Num<r8>(Power(5, 4)), [/] Num<r8>(Z))
Reducer: Mul(625, [/] Num<r8>(Z))
###
> 5 ^ 4 ^ Z
5^4^Z : i8
Binder : Power(5, Power(4, Num<i8>(Z)))
###
> 5 + Y
5 + Y : i8
Binder : Add(5, Num<i8>(Y))
Reducer: Add(Num<i8>(Y), 5)
###
> 5 - Y
5 - Y : i8
Binder : Add(5, [-] Num<i8>(Y))
Reducer: Add([-] Num<i8>(Y), 5)
###
> 5 * Y
5 * Y : i8
Binder : Mul(5, Num<i8>(Y))
Reducer: Mul(Num<i8>(Y), 5)
###
> 5 / Y
5 / Y : r8
Binder : Mul(5, [/] Num<r8>(Y))
###
> 5 ^ Y
5^Y : i8
Binder : Power(5, Num<i8>(Y))
###
> 5 + Y + 2
5 + Y + 2 : i8
Binder : Add(5, Num<i8>(Y), 2)
Reducer: Add(Num<i8>(Y), 7)
###
> 5 + Y - 2
5 + Y - 2 : i8
Binder : Add(5, Num<i8>(Y), [-] 2)
Reducer: Add(Num<i8>(Y), 3)
###
> 5 + Y * 2
5 + Y * 2 : i8
Binder : Add(5, Mul(Num<i8>(Y), 2))
Reducer: Add(Mul(Num<i8>(Y), 2), 5)
###
> 5 + Y / 2
5 + Y / 2 : r8
Binder : Add(5, Mul(Num<r8>(Y), [/] 2))
###
> 5 + Y ^ 2
5 + Y^2 : i8
Binder : Add(5, Power(Num<i8>(Y), 2))
Reducer: Add(Power(Num<i8>(Y), 2), 5)
###
> 5 - Y + 2
5 - Y + 2 : i8
Binder : Add(5, [-] Num<i8>(Y), 2)
Reducer: Add([-] Num<i8>(Y), 7)
###
> 5 - Y - 2
5 - Y - 2 : i8
Binder : Add(5, [-] Num<i8>(Y), [-] 2)
Reducer: Add([-] Num<i8>(Y), 3)
###
> 5 - Y * 2
5 - Y * 2 : i8
Binder : Add(5, [-] Mul(Num<i8>(Y), 2))
Reducer: Add([-] Mul(Num<i8>(Y), 2), 5)
###
> 5 - Y / 2
5 - Y / 2 : r8
Binder : Add(5, [-] Mul(Num<r8>(Y), [/] 2))
###
> 5 - Y ^ 2
5 - Y^2 : i8
Binder : Add(5, [-] Power(Num<i8>(Y), 2))
Reducer: Add([-] Power(Num<i8>(Y), 2), 5)
###
> 5 * Y + 2
5 * Y + 2 : i8
Binder : Add(Mul(5, Num<i8>(Y)), 2)
Reducer: Add(Mul(Num<i8>(Y), 5), 2)
###
> 5 * Y - 2
5 * Y - 2 : i8
Binder : Add(Mul(5, Num<i8>(Y)), [-] 2)
Reducer: Add(Mul(Num<i8>(Y), 5), [-] 2)
###
> 5 * Y * 2
5 * Y * 2 : i8
Binder : Mul(5, Num<i8>(Y), 2)
Reducer: Mul(Num<i8>(Y), 10)
###
> 5 * Y / 2
5 * Y / 2 : r8
Binder : Mul(Num<r8>(Mul(5, Num<i8>(Y))), [/] 2)
Reducer: Mul(Num<r8>(Mul(Num<i8>(Y), 5)), [/] 2)
###
> 5 * Y ^ 2
5 * Y^2 : i8
Binder : Mul(5, Power(Num<i8>(Y), 2))
Reducer: Mul(Power(Num<i8>(Y), 2), 5)
###
> 5 / Y + 2
5 / Y + 2 : r8
Binder : Add(Mul(5, [/] Num<r8>(Y)), 2)
###
> 5 / Y - 2
5 / Y - 2 : r8
Binder : Add(Mul(5, [/] Num<r8>(Y)), [-] 2)
###
> 5 / Y * 2
5 / Y * 2 : r8
Binder : Mul(5, [/] Num<r8>(Y), 2)
###
> 5 / Y / 2
5 / Y / 2 : r8
Binder : Mul(5, [/] Num<r8>(Y), [/] 2)
###
> 5 / Y ^ 2
5 / Y^2 : r8
Binder : Mul(5, [/] Num<r8>(Power(Num<i8>(Y), 2)))
###
> 5 ^ Y + 2
5^Y + 2 : i8
Binder : Add(Power(5, Num<i8>(Y)), 2)
###
> 5 ^ Y - 2
5^Y - 2 : i8
Binder : Add(Power(5, Num<i8>(Y)), [-] 2)
###
> 5 ^ Y * 2
5^Y * 2 : i8
Binder : Mul(Power(5, Num<i8>(Y)), 2)
###
> 5 ^ Y / 2
5^Y / 2 : r8
Binder : Mul(Num<r8>(Power(5, Num<i8>(Y))), [/] 2)
###
> 5 ^ Y ^ 2
5^Y^2 : i8
Binder : Power(5, Power(Num<i8>(Y), 2))
###
> X + 4
X + 4 : i8
Binder : Add(Num<i8>(X), 4)
###
> X - 4
X - 4 : i8
Binder : Add(Num<i8>(X), [-] 4)
###
> X * 4
X * 4 : i8
Binder : Mul(Num<i8>(X), 4)
###
> X / 4
X / 4 : r8
Binder : Mul(Num<r8>(X), [/] 4)
###
> X ^ 4
X^4 : i8
Binder : Power(Num<i8>(X), 4)
###
> X + 4 + 2
X + 4 + 2 : i8
Binder : Add(Num<i8>(X), 4, 2)
Reducer: Add(Num<i8>(X), 6)
###
> X + 4 - 2
X + 4 - 2 : i8
Binder : Add(Num<i8>(X), 4, [-] 2)
Reducer: Add(Num<i8>(X), 2)
###
> X + 4 * 2
X + 4 * 2 : i8
Binder : Add(Num<i8>(X), Mul(4, 2))
Reducer: Add(Num<i8>(X), 8)
###
> X + 4 / 2
X + 4 / 2 : r8
Binder : Add(Num<r8>(X), Mul(4, [/] 2))
Reducer: Add(Num<r8>(X), 2)
###
> X + 4 ^ 2
X + 4^2 : i8
Binder : Add(Num<i8>(X), Power(4, 2))
Reducer: Add(Num<i8>(X), 16)
###
> X - 4 + 2
X - 4 + 2 : i8
Binder : Add(Num<i8>(X), [-] 4, 2)
Reducer: Add(Num<i8>(X), -2)
###
> X - 4 - 2
X - 4 - 2 : i8
Binder : Add(Num<i8>(X), [-] 4, [-] 2)
Reducer: Add(Num<i8>(X), -6)
###
> X - 4 * 2
X - 4 * 2 : i8
Binder : Add(Num<i8>(X), [-] Mul(4, 2))
Reducer: Add(Num<i8>(X), [-] 8)
###
> X - 4 / 2
X - 4 / 2 : r8
Binder : Add(Num<r8>(X), [-] Mul(4, [/] 2))
Reducer: Add(Num<r8>(X), [-] 2)
###
> X - 4 ^ 2
X - 4^2 : i8
Binder : Add(Num<i8>(X), [-] Power(4, 2))
Reducer: Add(Num<i8>(X), [-] 16)
###
> X * 4 + 2
X * 4 + 2 : i8
Binder : Add(Mul(Num<i8>(X), 4), 2)
###
> X * 4 - 2
X * 4 - 2 : i8
Binder : Add(Mul(Num<i8>(X), 4), [-] 2)
###
> X * 4 * 2
X * 4 * 2 : i8
Binder : Mul(Num<i8>(X), 4, 2)
Reducer: Mul(Num<i8>(X), 8)
###
> X * 4 / 2
X * 4 / 2 : r8
Binder : Mul(Num<r8>(Mul(Num<i8>(X), 4)), [/] 2)
###
> X * 4 ^ 2
X * 4^2 : i8
Binder : Mul(Num<i8>(X), Power(4, 2))
Reducer: Mul(Num<i8>(X), 16)
###
> X / 4 + 2
X / 4 + 2 : r8
Binder : Add(Mul(Num<r8>(X), [/] 4), 2)
###
> X / 4 - 2
X / 4 - 2 : r8
Binder : Add(Mul(Num<r8>(X), [/] 4), [-] 2)
###
> X / 4 * 2
X / 4 * 2 : r8
Binder : Mul(Num<r8>(X), [/] 4, 2)
###
> X / 4 / 2
X / 4 / 2 : r8
Binder : Mul(Num<r8>(X), [/] 4, [/] 2)
###
> X / 4 ^ 2
X / 4^2 : r8
Binder : Mul(Num<r8>(X), [/] Num<r8>(Power(4, 2)))
Reducer: Mul(Num<r8>(X), [/] 16)
###
> X ^ 4 + 2
X^4 + 2 : i8
Binder : Add(Power(Num<i8>(X), 4), 2)
###
> X ^ 4 - 2
X^4 - 2 : i8
Binder : Add(Power(Num<i8>(X), 4), [-] 2)
###
> X ^ 4 * 2
X^4 * 2 : i8
Binder : Mul(Power(Num<i8>(X), 4), 2)
###
> X ^ 4 / 2
X^4 / 2 : r8
Binder : Mul(Num<r8>(Power(Num<i8>(X), 4)), [/] 2)
###
> X ^ 4 ^ 2
X^4^2 : i8
Binder : Power(Num<i8>(X), Power(4, 2))
Reducer: Power(Num<i8>(X), 16)
###
> 0 + X // Reduced to X.
0 + X : i8
Binder : Add(0, Num<i8>(X))
Reducer: Num<i8>(X)
###
> 0 - X // Reduced to Add([-] X).
0 - X : i8
Binder : Add(0, [-] Num<i8>(X))
Reducer: Add([-] Num<i8>(X))
###
> X + 0 // Reduced to X.
X + 0 : i8
Binder : Add(Num<i8>(X), 0)
Reducer: Num<i8>(X)
###
> X - 0 // Reduced to X.
X - 0 : i8
Binder : Add(Num<i8>(X), [-] 0)
Reducer: Num<i8>(X)
###
> 0 + B // Reduced to Cast<n>(B) + error.
0 + B : i8
*** Error: (4,5) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Add(0, Error(ErrBadType_Src_Dst))
Reducer: Error(ErrBadType_Src_Dst)
###
> 0 - B // Reduced to Add([-] Cast<n>(B)) + error.
0 - B : i8
*** Error: (4,5) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Add(0, [-] Error(ErrBadType_Src_Dst))
Reducer: Add([-] Error(ErrBadType_Src_Dst))
###
> B + 0 // Reduced to Cast<n>(B) + error.
B + 0 : i8
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Add(Error(ErrBadType_Src_Dst), 0)
Reducer: Error(ErrBadType_Src_Dst)
###
> B - 0 // Reduced to Cast<n>(B) + error.
B - 0 : i8
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Add(Error(ErrBadType_Src_Dst), [-] 0)
Reducer: Error(ErrBadType_Src_Dst)
###
> 1 * X // Reduced to X.
1 * X : i8
Binder : Mul(1, Num<i8>(X))
Reducer: Num<i8>(X)
###
> X * 1 // Reduced to X.
X * 1 : i8
Binder : Mul(Num<i8>(X), 1)
Reducer: Num<i8>(X)
###
> X / 1 // Reduced to X.
X / 1 : r8
Binder : Mul(Num<r8>(X), [/] 1)
Reducer: Num<r8>(X)
###
> 1 * B // Reduced to Cast<n>(B) + error.
1 * B : i8
*** Error: (4,5) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Mul(1, Error(ErrBadType_Src_Dst))
Reducer: Error(ErrBadType_Src_Dst)
###
> B * 1 // Reduced to Cast<n>(B) + error.
B * 1 : i8
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Mul(Error(ErrBadType_Src_Dst), 1)
Reducer: Error(ErrBadType_Src_Dst)
###
> B / 1 // Reduced to Cast<n>(B) + error.
B / 1 : r8
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'r8'
Binder : Mul(Error(ErrBadType_Src_Dst), [/] 1)
Reducer: Error(ErrBadType_Src_Dst)
###
> null + X // Reduced to null:n?.
null + X : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), Num<i8>(X)))
Reducer: null
###
> null - X // Reduced to null:n?.
null - X : i8?
Binder : Guard(?1: null, Add(Unit<i8>(?1), [-] Num<i8>(X)))
Reducer: null
###
> X + null // Reduced to null:n?.
X + null : i8?
Binder : Guard(?1: null, Add(Num<i8>(X), Unit<i8>(?1)))
Reducer: null
###
> X - null // Reduced to null:n?.
X - null : i8?
Binder : Guard(?1: null, Add(Num<i8>(X), [-] Unit<i8>(?1)))
Reducer: null
###
> null + B // Reduced to null:n? + error.
null + B : i8?
*** Error: (7,8) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Guard(?1: null, Add(Unit<i8>(?1), Error(ErrBadType_Src_Dst)))
Reducer: null
###
> null - B // Reduced to null:n? + error.
null - B : i8?
*** Error: (7,8) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Guard(?1: null, Add(Unit<i8>(?1), [-] Error(ErrBadType_Src_Dst)))
Reducer: null
###
> B + null // Reduced to null:n? + error.
B + null : i8?
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Guard(?1: null, Add(Error(ErrBadType_Src_Dst), Unit<i8>(?1)))
Reducer: null
###
> B - null // Reduced to null:n? + error.
B - null : i8?
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Guard(?1: null, Add(Error(ErrBadType_Src_Dst), [-] Unit<i8>(?1)))
Reducer: null
###
> null * X // Reduced to null:n?.
null * X : i8?
Binder : Guard(?1: null, Mul(Unit<i8>(?1), Num<i8>(X)))
Reducer: null
###
> null / X // Reduced to null:n?.
null / X : r8?
Binder : Guard(?1: null, Mul(Unit<r8>(?1), [/] Num<r8>(X)))
Reducer: null
###
> X * null // Reduced to null:n?.
X * null : i8?
Binder : Guard(?1: null, Mul(Num<i8>(X), Unit<i8>(?1)))
Reducer: null
###
> X / null // Reduced to null:n?.
X / null : r8?
Binder : Guard(?1: null, Mul(Num<r8>(X), [/] Unit<r8>(?1)))
Reducer: null
###
> null * B // Reduced to null:n? + error.
null * B : i8?
*** Error: (7,8) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Guard(?1: null, Mul(Unit<i8>(?1), Error(ErrBadType_Src_Dst)))
Reducer: null
###
> null / B // Reduced to null:n? + error.
null / B : r8?
*** Error: (7,8) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'r8'
Binder : Guard(?1: null, Mul(Unit<r8>(?1), [/] Error(ErrBadType_Src_Dst)))
Reducer: null
###
> B * null // Reduced to null:n? + error.
B * null : i8?
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'i8'
Binder : Guard(?1: null, Mul(Error(ErrBadType_Src_Dst), Unit<i8>(?1)))
Reducer: null
###
> B / null // Reduced to null:n? + error.
B / null : r8?
*** Error: (0,1) Node: B, Message: Invalid operand type: cannot convert type '(b, b)' to 'r8'
Binder : Guard(?1: null, Mul(Error(ErrBadType_Src_Dst), [/] Unit<r8>(?1)))
Reducer: null
###
> -(X * 3)
-(X * 3) : i8
Binder : Add([-] Mul(Num<i8>(X), 3))
###
> -(-X * 3)
-(-X * 3) : i8
Binder : Add([-] Mul(Add([-] Num<i8>(X)), 3))
Reducer: Add([-] Mul(Num<i8>(X), -3))
###
> -(X * -3)
-(X * -3) : i8
Binder : Add([-] Mul(Num<i8>(X), -3))
###
> -(X * -1)
-(X * -1) : i8
Binder : Add([-] Mul(Num<i8>(X), -1))
Reducer: Num<i8>(X)
###
> -X * 3
-X * 3 : i8
Binder : Mul(Add([-] Num<i8>(X)), 3)
Reducer: Mul(Num<i8>(X), -3)
###
> X * -X * 0x8000_0000_0000_0000i8 // Warning.
X * -X * 9223372036854775808 : i8
Binder : Mul(Num<i8>(X), Add([-] Num<i8>(X)), -9223372036854775808)
*** Warning: Node: Mul(Num<i8>(X), Add([-] Num<i8>(X)), -9223372036854775808), Message: Constant integer overflow
Reducer: Mul(Num<i8>(X), Num<i8>(X), -9223372036854775808)
###
> -X * -X * 0x8000_0000_0000_0000i8 // No warning.
-X * -X * 9223372036854775808 : i8
Binder : Mul(Add([-] Num<i8>(X)), Add([-] Num<i8>(X)), -9223372036854775808)
Reducer: Mul(Num<i8>(X), Num<i8>(X), -9223372036854775808)
###
> -X * -Y
-X * -Y : i8
Binder : Mul(Add([-] Num<i8>(X)), Add([-] Num<i8>(Y)))
Reducer: Mul(Num<i8>(X), Num<i8>(Y))
###
> -X / -Y
-X / -Y : r8
Binder : Mul(Num<r8>(Add([-] Num<i8>(X))), [/] Num<r8>(Add([-] Num<i8>(Y))))
###
> -X / -Y * -Z
-X / -Y * -Z : r8
Binder : Mul(Num<r8>(Add([-] Num<i8>(X))), [/] Num<r8>(Add([-] Num<i8>(Y))), Num<r8>(Add([-] Num<i8>(Z))))
###
> -(-X / -Y * -Z)
-(-X / -Y * -Z) : r8
Binder : Add([-] Mul(Num<r8>(Add([-] Num<i8>(X))), [/] Num<r8>(Add([-] Num<i8>(Y))), Num<r8>(Add([-] Num<i8>(Z)))))
###
> -(-X / -Y) * -Z
-(-X / -Y) * -Z : r8
Binder : Mul(Add([-] Mul(Num<r8>(Add([-] Num<i8>(X))), [/] Num<r8>(Add([-] Num<i8>(Y))))), Num<r8>(Add([-] Num<i8>(Z))))
Reducer: Mul(Num<r8>(Add([-] Num<i8>(X))), [/] Num<r8>(Add([-] Num<i8>(Y))), Num<r8>(Add([-] Num<i8>(Z))), -1)
###

**** New globals: {A:i4*, B:i4?*, R:{S:{X:i4}*, X:i4, Y:i2}*, X:i4}

> -(A * A)
-(A * A) : i8*
Binder : ForEach(*3: ForEach(*1: A, *2: A, Mul(Num<i8>(*1), Num<i8>(*2))), Add([-] *3))
Reducer: ForEach(*1: A, Add([-] Mul(Num<i8>(*1), Num<i8>(*1))))
###
> A * B
A * B : i8?*
Binder : ForEach(*1: A, *2: B, Guard(?3: *2, Mul(Num<i8>(*1), Num<i8>(?3))))
###
> A * B * A
A * B * A : i8?*
Binder : ForEach(*4: ForEach(*1: A, *2: B, Guard(?3: *2, Mul(Num<i8>(*1), Num<i8>(?3)))), *5: A, Guard(?6: *4, Mul(?6, Num<i8>(*5))))
Reducer: ForEach(*1: A, *2: B, Guard(?3: *2, Mul(Num<i8>(*1), Num<i8>(?3), Num<i8>(*1))))
###
> -A * B * A
-A * B * A : i8?*
Binder : ForEach(*5: ForEach(*2: ForEach(*1: A, Add([-] Num<i8>(*1))), *3: B, Guard(?4: *3, Mul(*2, Num<i8>(?4)))), *6: A, Guard(?7: *5, Mul(?7, Num<i8>(*6))))
Reducer: ForEach(*1: A, *2: B, Guard(?3: *2, Add([-] Mul(Num<i8>(*1), Num<i8>(?3), Num<i8>(*1)))))
###
> -(A * B) * A
-(A * B) * A : i8?*
Binder : ForEach(*6: ForEach(*4: ForEach(*1: A, *2: B, Guard(?3: *2, Mul(Num<i8>(*1), Num<i8>(?3)))), Guard(?5: *4, Add([-] ?5))), *7: A, Guard(?8: *6, Mul(?8, Num<i8>(*7))))
Reducer: ForEach(*1: A, *2: B, Guard(?3: *2, Add([-] Mul(Num<i8>(*1), Num<i8>(?3), Num<i8>(*1)))))
###
> -(A * B * A)
-(A * B * A) : i8?*
Binder : ForEach(*7: ForEach(*4: ForEach(*1: A, *2: B, Guard(?3: *2, Mul(Num<i8>(*1), Num<i8>(?3)))), *5: A, Guard(?6: *4, Mul(?6, Num<i8>(*5)))), Guard(?8: *7, Add([-] ?8)))
Reducer: ForEach(*1: A, *2: B, Guard(?3: *2, Add([-] Mul(Num<i8>(*1), Num<i8>(?3), Num<i8>(*1)))))
###
> R.X * R.X
R.X * R.X : i8*
Binder : ForEach(*3: ForEach(*1: R, *1.X), *4: ForEach(*2: R, *2.X), Mul(Num<i8>(*3), Num<i8>(*4)))
Reducer: ForEach(*1: R, Mul(Num<i8>(*1.X), Num<i8>(*1.X)))
###
> R.X * R.Y
R.X * R.Y : i8*
Binder : ForEach(*3: ForEach(*1: R, *1.X), *4: ForEach(*2: R, *2.Y), Mul(Num<i8>(*3), Num<i8>(*4)))
Reducer: ForEach(*1: R, Mul(Num<i8>(*1.X), Num<i8>(*1.Y)))
###
> R.X * R.Y * R.S.X
R.X * R.Y * R.S.X : i8**
Binder : ForEach(*8: ForEach(*3: ForEach(*1: R, *1.X), *4: ForEach(*2: R, *2.Y), Mul(Num<i8>(*3), Num<i8>(*4))), *9: ForEach(*6: ForEach(*5: R, *5.S), ForEach(*7: *6, *7.X)), ForEach(*10: *9, Mul(*8, Num<i8>(*10))))
Reducer: ForEach(*1: R, With(!2: Mul(Num<i8>(*1.X), Num<i8>(*1.Y)), ForEach(*3: *1.S, Mul(!2, Num<i8>(*3.X)))))
###
> A * R.X
A * R.X : i8*
Binder : ForEach(*2: A, *3: ForEach(*1: R, *1.X), Mul(Num<i8>(*2), Num<i8>(*3)))
Reducer: ForEach(*1: A, *2: R, Mul(Num<i8>(*1), Num<i8>(*2.X)))
###
> With(x : R, x.X) * With(y : R, y.X)
With(x : R, x.X) * With(y : R, y.X) : i8*
Binder : ForEach(*5: With(!1: R, ForEach(*2: !1, *2.X)), *6: With(!3: R, ForEach(*4: !3, *4.X)), Mul(Num<i8>(*5), Num<i8>(*6)))
Reducer: ForEach(*1: R, Mul(Num<i8>(*1.X), Num<i8>(*1.X)))
###
