Dec constants was changed with hex constants.

tests/padds_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32
+    uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int32) 2147483647;
+        RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int32) -2147483648;
+        RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
     }
     else {
-        RET[programIndex] = (uniform int32) -2147483643;
+        RET[programIndex] = (uniform int32) -0x7FFFFFFB; // min + 5
     } 
 }

tests/padds_i64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64
+    uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int64) 9223372036854775807;
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int64) -9223372036854775808;
+        RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64
     }
     else {
-        RET[programIndex] = (uniform int64) -9223372036854775803;
+        RET[programIndex] = (uniform int64) -0x7FFFFFFFFFFFFFFB; // min + 5
     } 
 }

tests/padds_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32
+    varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int32) 2147483647;
+        RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int32) -2147483648;
+        RET[programIndex] = (varying int32) -0x80000000; // min signed int32
     }
     else {
-        RET[programIndex] = (varying int32) -2147483643;
+        RET[programIndex] = (varying int32) -0x7FFFFFFB; // min + 5
     } 
 }

tests/padds_vi64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64
+    varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int64) 9223372036854775807;
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int64) -9223372036854775808;
+        RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64
     }
     else {
-        RET[programIndex] = (varying int64) -9223372036854775803;
+        RET[programIndex] = (varying int64) -0x7FFFFFFFFFFFFFFB; // min + 5
     } 
 }

tests/paddus_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int32) 4294967295;
+        RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFF; // max unsigned int32
     }
     else {
         RET[programIndex] = (uniform unsigned int32) 5;

tests/paddus_i64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64
+    uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int64) 18446744073709551615;
+        RET[programIndex] = (uniform unsigned int64) 0xFFFFFFFFFFFFFFFF; // max unsigned int64
     }
     else {
         RET[programIndex] = (uniform unsigned int64) 5;

tests/paddus_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int32) 4294967295;
+        RET[programIndex] = (varying unsigned int32) 0xFFFFFFFF; // max unsigned int32
     }
     else {
         RET[programIndex] = (varying unsigned int32) 5;

tests/paddus_vi64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64
+    varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_add(a_max, b);
     }
@@ -13,7 +13,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int64) 18446744073709551615;
+        RET[programIndex] = (varying unsigned int64) 0xFFFFFFFFFFFFFFFF; // max unsigned int64
     }
     else {
         RET[programIndex] = (varying unsigned int64) 5;

tests/pdivs_i16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int16 a_max = 32767, a_min = -32768; // max and min signed int16
+    uniform int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (uniform int16) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int16) 6553.4;
+        RET[programIndex] = (uniform int16) 6553.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int16) -6553.6;
+        RET[programIndex] = (uniform int16) -6553.6; // min / 5 
     }
     else {
-        RET[programIndex] = (uniform int16) 32767;
+        RET[programIndex] = (uniform int16) 0x7FFF; // max signed int16
     } 
 }

tests/pdivs_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32
+    uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (uniform int32) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int32) 429496729.4;
+        RET[programIndex] = (uniform int32) 429496729.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int32) -429496729.6;
+        RET[programIndex] = (uniform int32) -429496729.6; // min / 5 
     }
     else {
-        RET[programIndex] = (uniform int32) 2147483647;
+        RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
     } 
 }

tests/pdivs_i64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64
+    uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (uniform int64) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int64) 1844674407370955161.4;
+        RET[programIndex] = (uniform int64) 1844674407370955161.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int64) -1844674407370955161.6;
+        RET[programIndex] = (uniform int64) -1844674407370955161.6; // min / 5 
     }
     else {
-        RET[programIndex] = (uniform int64) 9223372036854775807;
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
     } 
 }

tests/pdivs_i8.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int8 a_max = 127, a_min = -128; // max and min signed int8
+    uniform int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (uniform int8) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int8) 25.4;
+        RET[programIndex] = (uniform int8) 25.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int8) -25.6;
+        RET[programIndex] = (uniform int8) -25.6; // min / 5 
     }
     else {
-        RET[programIndex] = (uniform int8) 127;
+        RET[programIndex] = (uniform int8) 0x7F; // max signed int8
     } 
 }

tests/pdivs_vi16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int16 a_max = 32767, a_min = -32768; // max and min signed int16
+    varying int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (varying int16) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int16) 6553.4;
+        RET[programIndex] = (varying int16) 6553.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int16) -6553.6;
+        RET[programIndex] = (varying int16) -6553.6; // min / 5 
     }
     else {
-        RET[programIndex] = (varying int16) 32767;
+        RET[programIndex] = (varying int16) 0x7FFF; // max signed int16
     } 
 }

tests/pdivs_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32
+    varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (varying int32) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int32) 429496729.4;
+        RET[programIndex] = (varying int32) 429496729.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int32) -429496729.6;
+        RET[programIndex] = (varying int32) -429496729.6; // min / 5 
     }
     else {
-        RET[programIndex] = (varying int32) 2147483647;
+        RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
     } 
 }

tests/pdivs_vi64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min signed int64
+    varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (varying int64) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int64) 1844674407370955161.4;
+        RET[programIndex] = (varying int64) 1844674407370955161.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int64) -1844674407370955161.6;
+        RET[programIndex] = (varying int64) -1844674407370955161.6; // min / 5 
     }
     else {
-        RET[programIndex] = (varying int64) 9223372036854775807;
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
     } 
 }

tests/pdivs_vi8.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int8 a_max = 127, a_min = -128; // max and min signed int8
+    varying int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_div(a_max, (varying int8) b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int8) 25.4;
+        RET[programIndex] = (varying int8) 25.4; // max / 5
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int8) -25.6;
+        RET[programIndex] = (varying int8) -25.6; // min / 5 
     }
     else {
-        RET[programIndex] = (varying int8) 127;
+        RET[programIndex] = (varying int8) 0x7F; // max signed int8
     } 
 }

tests/pdivus_i16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16
+    uniform unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (uniform unsigned int16) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int16) 0;
+        RET[programIndex] = (uniform unsigned int16) 0; // min unsigned int16
     }
     else {
-        RET[programIndex] = (uniform unsigned int16) 13107;
+        RET[programIndex] = (uniform unsigned int16) 0x3333; // max unsigned int16 / 5
     } 
 }

tests/pdivus_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (uniform unsigned int32) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int32) 0;
+        RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32
     }
     else {
-        RET[programIndex] = (uniform unsigned int32) 858993459;
+        RET[programIndex] = (uniform unsigned int32) 0x33333333; // max unsigned int32 / 5
     } 
 }

tests/pdivus_i64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64
+    uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (uniform unsigned int64) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int64) 0;
+        RET[programIndex] = (uniform unsigned int64) 0; // min unsigned int64
     }
     else {
-        RET[programIndex] = (uniform unsigned int64) 3689348814741910323;
+        RET[programIndex] = (uniform unsigned int64) 0x3333333333333333; // max unsigned int64 / 5
     } 
 }

tests/pdivus_i8.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8
+    uniform unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (uniform unsigned int8) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int8) 0;
+        RET[programIndex] = (uniform unsigned int8) 0; // min unsigned int8
     }
     else {
-        RET[programIndex] = (uniform unsigned int8) 51;
+        RET[programIndex] = (uniform unsigned int8) 0x33; // max unsigned int8 / 5
     } 
 }

tests/pdivus_vi16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16
+    varying unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (varying unsigned int16) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int16) 0;
+        RET[programIndex] = (varying unsigned int16) 0; // min unsigned int16
     }
     else {
-        RET[programIndex] = (varying unsigned int16) 13107;
+        RET[programIndex] = (varying unsigned int16) 0x3333; // max unsigned int16 / 5
     } 
 }

tests/pdivus_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (varying unsigned int32) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int32) 0;
+        RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32
     }
     else {
-        RET[programIndex] = (varying unsigned int32) 858993459;
+        RET[programIndex] = (varying unsigned int32) 0x33333333; // max unsigned int32 / 5
     } 
 }

tests/pdivus_vi64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64
+    varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (varying unsigned int64) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int64) 0;
+        RET[programIndex] = (varying unsigned int64) 0; // min unsigned int64
     }
     else {
-        RET[programIndex] = (varying unsigned int64) 3689348814741910323;
+        RET[programIndex] = (varying unsigned int64) 0x3333333333333333; // max unsigned int64 / 5
     } 
 }

tests/pdivus_vi8.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8
+    varying unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_div(a_min, (varying unsigned int8) b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int8) 0;
+        RET[programIndex] = (varying unsigned int8) 0; // min unsigned int8
     }
     else {
-        RET[programIndex] = (varying unsigned int8) 51;
+        RET[programIndex] = (varying unsigned int8) 0x33; // max unsigned int8 / 5
     } 
 }

tests/pmuls_i16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int16 a_max = 32767, a_min = -32768; // max and min signed int16
+    uniform int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (uniform int16) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int16) 32767;
+        RET[programIndex] = (uniform int16) 0x7FFF; // max signed int16
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int16) -32768;
+        RET[programIndex] = (uniform int16) -0x8000; // min signed int16
     }
     else {
         RET[programIndex] = (uniform int16) 25;

tests/pmuls_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32
+    uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (uniform int32) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int32) 2147483647;
+        RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int32) -2147483648;
+        RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
     }
     else {
         RET[programIndex] = (uniform int32) 25;

tests/pmuls_i8.ispc

@@ -1,9 +1,8 @@
 
-
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int8 a_max = 127, a_min = -128; // max and min signed int8
+    uniform int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (uniform int8) b);
     }
@@ -18,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int8) 127;
+        RET[programIndex] = (uniform int8) 0x7F; // max signed int8
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int8) -128;
+        RET[programIndex] = (uniform int8) -0x80; // min signed int8
     }
     else {
         RET[programIndex] = (uniform int8) 25;

tests/pmuls_vi16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int16 a_max = 32767, a_min = -32768; // max and min signed int16
+    varying int16 a_max = 0x7FFF, a_min = -0x8000; // max and min signed int16
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (varying int16) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int16) 32767;
+        RET[programIndex] = (varying int16) 0x7FFF; // max signed int16
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int16) -32768;
+        RET[programIndex] = (varying int16) -0x8000; // min signed int16
     }
     else {
         RET[programIndex] = (varying int16) 25;

tests/pmuls_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int32 a_max = 2147483647, a_min = -2147483648; // max and min signed int32
+    varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (varying int32) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int32) 2147483647;
+        RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int32) -2147483648;
+        RET[programIndex] = (varying int32) -0x80000000; // min signed int32
     }
     else {
         RET[programIndex] = (varying int32) 25;

tests/pmuls_vi8.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int8 a_max = 127, a_min = -128; // max and min signed int8
+    varying int8 a_max = 0x7F, a_min = -0x80; // max and min signed int8
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (varying int8) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int8) 127;
+        RET[programIndex] = (varying int8) 0x7F; // max signed int8
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int8) -128;
+        RET[programIndex] = (varying int8) -0x80; // min signed int8
     }
     else {
         RET[programIndex] = (varying int8) 25;

tests/pmulus_i16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16
+    uniform unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (uniform unsigned int16) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform unsigned int16) 65535;
+        RET[programIndex] = (uniform unsigned int16) 0xFFFF; // max unsigned int16
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform unsigned int16) 0;
+        RET[programIndex] = (uniform unsigned int16) 0; // min unsigned int16
     }
     else {
         RET[programIndex] = (uniform unsigned int16) 25;

tests/pmulus_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (uniform unsigned int32) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform unsigned int32) 4294967295;
+        RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFF; // max unsigned int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform unsigned int32) 0;
+        RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32
     }
     else {
         RET[programIndex] = (uniform unsigned int32) 25;

tests/pmulus_i8.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8
+    uniform unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (uniform unsigned int8) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform unsigned int8) 255;
+        RET[programIndex] = (uniform unsigned int8) 0xFF; // max unsigned int8
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform unsigned int8) 0;
+        RET[programIndex] = (uniform unsigned int8) 0; // min unsigned int8
     }
     else {
         RET[programIndex] = (uniform unsigned int8) 25;

tests/pmulus_vi16.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int16 a_max = 65535, a_min = 0; // max and min unsigned int16
+    varying unsigned int16 a_max = 0xFFFF, a_min = 0; // max and min unsigned int16
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (varying unsigned int16) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying unsigned int16) 65535;
+        RET[programIndex] = (varying unsigned int16) 0xFFFF; // max unsigned int16
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying unsigned int16) 0;
+        RET[programIndex] = (varying unsigned int16) 0; // min unsigned int16
     }
     else {
         RET[programIndex] = (varying unsigned int16) 25;

tests/pmulus_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (varying unsigned int32) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying unsigned int32) 4294967295;
+        RET[programIndex] = (varying unsigned int32) 0xFFFFFFFF; // max unsigned int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying unsigned int32) 0;
+        RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32
     }
     else {
         RET[programIndex] = (varying unsigned int32) 25;

tests/pmulus_vi8.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int8 a_max = 255, a_min = 0; // max and min unsigned int8
+    varying unsigned int8 a_max = 0xFF, a_min = 0; // max and min unsigned int8
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_mul(a_max, (varying unsigned int8) b);
     }
@@ -17,10 +17,10 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying unsigned int8) 255;
+        RET[programIndex] = (varying unsigned int8) 0xFF; // max unsigned int8
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying unsigned int8) 0;
+        RET[programIndex] = (varying unsigned int8) 0; // min unsigned int8
     }
     else {
         RET[programIndex] = (varying unsigned int8) 25;

tests/psubs_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int32 a_max = 2147483647, a_min = -2147483648; // max and min int32
+    uniform int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int32) -2147483648;
+        RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int32) 2147483647;
+        RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
     }
     else {
-        RET[programIndex] = (uniform int32) 2147483642;
+        RET[programIndex] = (uniform int32) 0x7FFFFFFA;
     } 
 }

tests/psubs_i64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min int64
+    uniform int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (uniform int64) -9223372036854775808;
+        RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (uniform int64) 9223372036854775807;
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
     }
     else {
-        RET[programIndex] = (uniform int64) 9223372036854775802;
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFA;
     } 
 }

tests/psubs_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int32 a_max = 2147483647, a_min = -2147483648; // max and min int32
+    varying int32 a_max = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int32) -2147483648;
+        RET[programIndex] = (varying int32) -0x80000000; // min signed int32
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int32) 2147483647;
+        RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
     }
     else {
-        RET[programIndex] = (varying int32) 2147483642;
+        RET[programIndex] = (varying int32) 0x7FFFFFFA;
     } 
 }

tests/psubs_vi64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying int64 a_max = 9223372036854775807, a_min = -9223372036854775808; // max and min int64
+    varying int64 a_max = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64
     if (programIndex % 3 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -16,12 +16,12 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 3 == 0) {
-        RET[programIndex] = (varying int64) -9223372036854775808;
+        RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64
     }
     else if (programIndex % 3 == 1) {
-        RET[programIndex] = (varying int64) 9223372036854775807;
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
     }
     else {
-        RET[programIndex] = (varying int64) 9223372036854775802;
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFA;
     } 
 }

tests/psubus_i32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    uniform unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int32) 0;
+        RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32
     }
     else {
-        RET[programIndex] = (uniform unsigned int32) 4294967290;
+        RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5
     } 
 }

tests/psubus_i64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64
+    uniform unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (uniform unsigned int64) 0;
+        RET[programIndex] = (uniform unsigned int64) 0; // min unsigned int64
     }
     else {
-        RET[programIndex] = (uniform unsigned int64) 18446744073709551610;
+        RET[programIndex] = (uniform unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5
     } 
 }

tests/psubus_vi32.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int32 a_max = 4294967295, a_min = 0; // max and min unsigned int32
+    varying unsigned int32 a_max = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int32) 0;
+        RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32
     }
     else {
-        RET[programIndex] = (varying unsigned int32) 4294967290;
+        RET[programIndex] = (varying unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5
     } 
 }

tests/psubus_vi64.ispc

@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    varying unsigned int64 a_max = 18446744073709551615, a_min = 0; // max and min unsigned int64
+    varying unsigned int64 a_max = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
     if (programIndex % 2 == 0) {
         RET[programIndex] = saturating_sub(a_min, b);
     }
@@ -13,9 +13,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) {
     if (programIndex % 2 == 0) {
-        RET[programIndex] = (varying unsigned int64) 0;
+        RET[programIndex] = (varying unsigned int64) 0; // min unsigned int64
     }
     else {
-        RET[programIndex] = (varying unsigned int64) 18446744073709551610;
+        RET[programIndex] = (varying unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5
     } 
 }