diff --git a/tests/padds_i32.ispc b/tests/padds_i32.ispc
index a92e640f..866f8496 100644
--- a/tests/padds_i32.ispc
+++ b/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
     } 
 }
diff --git a/tests/padds_i64.ispc b/tests/padds_i64.ispc
index be21dc88..6b61b394 100644
--- a/tests/padds_i64.ispc
+++ b/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
     } 
 }
diff --git a/tests/padds_vi32.ispc b/tests/padds_vi32.ispc
index f566f84b..a51bdad9 100644
--- a/tests/padds_vi32.ispc
+++ b/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
     } 
 }
diff --git a/tests/padds_vi64.ispc b/tests/padds_vi64.ispc
index c8492fb4..9b577a79 100644
--- a/tests/padds_vi64.ispc
+++ b/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
     } 
 }
diff --git a/tests/paddus_i32.ispc b/tests/paddus_i32.ispc
index 2745b5eb..2a159340 100644
--- a/tests/paddus_i32.ispc
+++ b/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;
diff --git a/tests/paddus_i64.ispc b/tests/paddus_i64.ispc
index ff63307d..38b5c4fe 100644
--- a/tests/paddus_i64.ispc
+++ b/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;
diff --git a/tests/paddus_vi32.ispc b/tests/paddus_vi32.ispc
index eaa4097f..555d9837 100644
--- a/tests/paddus_vi32.ispc
+++ b/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;
diff --git a/tests/paddus_vi64.ispc b/tests/paddus_vi64.ispc
index 3694125e..cf99be72 100644
--- a/tests/paddus_vi64.ispc
+++ b/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;
diff --git a/tests/pdivs_i16.ispc b/tests/pdivs_i16.ispc
index b9b5858f..7dede2a7 100644
--- a/tests/pdivs_i16.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivs_i32.ispc b/tests/pdivs_i32.ispc
index 99760828..d6d1d97d 100644
--- a/tests/pdivs_i32.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivs_i64.ispc b/tests/pdivs_i64.ispc
index e0de47f7..4a3bb268 100644
--- a/tests/pdivs_i64.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivs_i8.ispc b/tests/pdivs_i8.ispc
index c68dcd64..0fa71253 100644
--- a/tests/pdivs_i8.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivs_vi16.ispc b/tests/pdivs_vi16.ispc
index 0b119672..482fbfcb 100644
--- a/tests/pdivs_vi16.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivs_vi32.ispc b/tests/pdivs_vi32.ispc
index 4f6b0bae..1c699b68 100644
--- a/tests/pdivs_vi32.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivs_vi64.ispc b/tests/pdivs_vi64.ispc
index cb4fba70..00913ea3 100644
--- a/tests/pdivs_vi64.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivs_vi8.ispc b/tests/pdivs_vi8.ispc
index 7b021645..3e039a01 100644
--- a/tests/pdivs_vi8.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_i16.ispc b/tests/pdivus_i16.ispc
index 827eedfc..c7573d78 100644
--- a/tests/pdivus_i16.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_i32.ispc b/tests/pdivus_i32.ispc
index ec4c97be..c11b68fe 100644
--- a/tests/pdivus_i32.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_i64.ispc b/tests/pdivus_i64.ispc
index ddc4d866..51354ce7 100644
--- a/tests/pdivus_i64.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_i8.ispc b/tests/pdivus_i8.ispc
index 0c133a1d..1b509c30 100644
--- a/tests/pdivus_i8.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_vi16.ispc b/tests/pdivus_vi16.ispc
index 754399db..71696f7e 100644
--- a/tests/pdivus_vi16.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_vi32.ispc b/tests/pdivus_vi32.ispc
index 3d6172db..0c8a8f25 100644
--- a/tests/pdivus_vi32.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_vi64.ispc b/tests/pdivus_vi64.ispc
index e7e8ca20..1aef75f7 100644
--- a/tests/pdivus_vi64.ispc
+++ b/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
     } 
 }
diff --git a/tests/pdivus_vi8.ispc b/tests/pdivus_vi8.ispc
index 7bcd7f1d..f4a5adaf 100644
--- a/tests/pdivus_vi8.ispc
+++ b/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
     } 
 }
diff --git a/tests/pmuls_i16.ispc b/tests/pmuls_i16.ispc
index f7e58a7f..38e8794f 100644
--- a/tests/pmuls_i16.ispc
+++ b/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;
diff --git a/tests/pmuls_i32.ispc b/tests/pmuls_i32.ispc
index aca6324d..51a2f6ba 100644
--- a/tests/pmuls_i32.ispc
+++ b/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;
diff --git a/tests/pmuls_i8.ispc b/tests/pmuls_i8.ispc
index 0b14f5bb..aa2419c7 100644
--- a/tests/pmuls_i8.ispc
+++ b/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;
diff --git a/tests/pmuls_vi16.ispc b/tests/pmuls_vi16.ispc
index b2f153e6..4d467b28 100644
--- a/tests/pmuls_vi16.ispc
+++ b/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;
diff --git a/tests/pmuls_vi32.ispc b/tests/pmuls_vi32.ispc
index d4030e0d..00a178da 100644
--- a/tests/pmuls_vi32.ispc
+++ b/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;
diff --git a/tests/pmuls_vi8.ispc b/tests/pmuls_vi8.ispc
index d8da3465..33975f51 100644
--- a/tests/pmuls_vi8.ispc
+++ b/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;
diff --git a/tests/pmulus_i16.ispc b/tests/pmulus_i16.ispc
index b01a1acd..bbf9182f 100644
--- a/tests/pmulus_i16.ispc
+++ b/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;
diff --git a/tests/pmulus_i32.ispc b/tests/pmulus_i32.ispc
index d7116f12..3f926d2d 100644
--- a/tests/pmulus_i32.ispc
+++ b/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;
diff --git a/tests/pmulus_i8.ispc b/tests/pmulus_i8.ispc
index f70fe716..71504ae3 100644
--- a/tests/pmulus_i8.ispc
+++ b/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;
diff --git a/tests/pmulus_vi16.ispc b/tests/pmulus_vi16.ispc
index 256c0365..427bf632 100644
--- a/tests/pmulus_vi16.ispc
+++ b/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;
diff --git a/tests/pmulus_vi32.ispc b/tests/pmulus_vi32.ispc
index b109d2cf..0e5a09b3 100644
--- a/tests/pmulus_vi32.ispc
+++ b/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;
diff --git a/tests/pmulus_vi8.ispc b/tests/pmulus_vi8.ispc
index 1dc46697..d378ee52 100644
--- a/tests/pmulus_vi8.ispc
+++ b/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;
diff --git a/tests/psubs_i32.ispc b/tests/psubs_i32.ispc
index 9fefd861..7b4bad63 100644
--- a/tests/psubs_i32.ispc
+++ b/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;
     } 
 }
diff --git a/tests/psubs_i64.ispc b/tests/psubs_i64.ispc
index b1e061bc..dd7b5715 100644
--- a/tests/psubs_i64.ispc
+++ b/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;
     } 
 }
diff --git a/tests/psubs_vi32.ispc b/tests/psubs_vi32.ispc
index 1dd2720c..6c3800ec 100644
--- a/tests/psubs_vi32.ispc
+++ b/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;
     } 
 }
diff --git a/tests/psubs_vi64.ispc b/tests/psubs_vi64.ispc
index 75a9711e..887134b4 100644
--- a/tests/psubs_vi64.ispc
+++ b/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;
     } 
 }
diff --git a/tests/psubus_i32.ispc b/tests/psubus_i32.ispc
index dc188fc3..a3352d5d 100644
--- a/tests/psubus_i32.ispc
+++ b/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
     } 
 }
diff --git a/tests/psubus_i64.ispc b/tests/psubus_i64.ispc
index bca59a40..d1a6ee51 100644
--- a/tests/psubus_i64.ispc
+++ b/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
     } 
 }
diff --git a/tests/psubus_vi32.ispc b/tests/psubus_vi32.ispc
index dffcaeb4..22a42963 100644
--- a/tests/psubus_vi32.ispc
+++ b/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
     } 
 }
diff --git a/tests/psubus_vi64.ispc b/tests/psubus_vi64.ispc
index e56d8972..870d468a 100644
--- a/tests/psubus_vi64.ispc
+++ b/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
     } 
 }