diff --git a/stdlib.ispc b/stdlib.ispc
index 160c520d..f76ed15c 100644
--- a/stdlib.ispc
+++ b/stdlib.ispc
@@ -4612,6 +4612,216 @@ static inline varying unsigned int64 saturating_sub(varying unsigned int64 a,
     result &= (-(varying int64)(result <= a));
     return result;
 }
+
+static inline uniform int8 saturating_div(uniform int8 a, uniform int8 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((uniform unsigned int8) a + INT8_MIN));
+    return a / b;
+}
+
+static inline varying int8 saturating_div(varying int8 a, varying int8 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((varying unsigned int8) a + INT8_MIN));
+    return a / b;
+}
+
+static inline uniform int16 saturating_div(uniform int16 a, uniform int16 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((uniform unsigned int16) a + INT16_MIN));
+    return a / b;
+}
+
+static inline varying int16 saturating_div(varying int16 a, varying int16 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((varying unsigned int16) a + INT16_MIN));
+    return a / b;
+}
+
+static inline uniform int32 saturating_div(uniform int32 a, uniform int32 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((uniform unsigned int32) a + INT32_MIN));
+    return a / b;
+}
+
+static inline varying int32 saturating_div(varying int32 a, varying int32 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((varying unsigned int32) a + INT32_MIN));
+    return a / b;
+}
+
+static inline uniform int64 saturating_div(uniform int64 a, uniform int64 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((uniform unsigned int64) a + INT64_MIN));
+    return a / b;
+}
+
+static inline varying int64 saturating_div(varying int64 a, varying int64 b) {
+    /* Only one way to overflow, so test for and prevent it. */
+    a += !((b + 1) | ((varying unsigned int64) a + INT64_MIN));
+    return a / b;
+}
+
+static inline uniform unsigned int8 saturating_div(uniform unsigned int8 a,
+	                                               uniform unsigned int8 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline varying unsigned int8 saturating_div(varying unsigned int8 a, 
+                                                   varying unsigned int8 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline uniform unsigned int16 saturating_div(uniform unsigned int16 a,
+                                                    uniform unsigned int16 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline varying unsigned int16 saturating_div(varying unsigned int16 a, 
+                                                    varying unsigned int16 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline uniform unsigned int32 saturating_div(uniform unsigned int32 a, 
+                                                    uniform unsigned int32 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline varying unsigned int32 saturating_div(varying unsigned int32 a,
+                                                    varying unsigned int32 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline uniform unsigned int64 saturating_div(uniform unsigned int64 a, 
+                                                    uniform unsigned int64 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline varying unsigned int64 saturating_div(varying unsigned int64 a, 
+                                                    varying unsigned int64 b) {
+    /* No overflow possible */
+    return a / b;
+}
+
+static inline uniform int8 saturating_mul(uniform int8 a, uniform int8 b) {
+    uniform int16 result = (uniform int16) a * (uniform int16) b;	
+    uniform unsigned int8 result2 = ((uniform unsigned int8) (a ^ b) >> 7) + INT8_MAX;
+    uniform int8 hi = result >> 8;
+    uniform int8 lo = result;
+    if (hi != (lo >> 7)) 
+        result = result2;
+    return result; 
+}
+
+static inline varying int8 saturating_mul(varying int8 a, varying int8 b) {
+    varying int16 result = (varying int16) a * (varying int16) b;	
+    varying unsigned int8 result2 = ((varying unsigned int8) (a ^ b) >> 7) + INT8_MAX;
+    varying int8 hi = result >> 8;
+    varying int8 lo = result;
+    if (hi != (lo >> 7)) 
+        result = result2;
+    return result; 
+}
+
+static inline uniform int16 saturating_mul(uniform int16 a, uniform int16 b) {
+    uniform int32 result = (uniform int32) a * (uniform int32) b;	
+    uniform unsigned int16 result2 = ((uniform unsigned int16) (a ^ b) >> 15) + INT16_MAX;
+    uniform int16 hi = result >> 16;
+    uniform int16 lo = result;
+    if (hi != (lo >> 15)) 
+        result = result2;
+    return result; 
+}
+
+static inline varying int16 saturating_mul(varying int16 a, varying int16 b) {
+    varying int32 result = (varying int32) a * (varying int32) b;	
+    varying unsigned int16 result2 = ((varying unsigned int16) (a ^ b) >> 15) + INT16_MAX;
+    varying int16 hi = result >> 16;
+    varying int16 lo = result;
+    if (hi != (lo >> 15)) 
+        result = result2;
+    return result; 
+}
+
+static inline uniform int32 saturating_mul(uniform int32 a, uniform int32 b) {
+    uniform int64 result = (uniform int64) a * (uniform int64) b;	
+    uniform unsigned int32 result2 = ((uniform unsigned int32) (a ^ b) >> 31) + INT32_MAX;
+    uniform int32 hi = result >> 32;
+    uniform int32 lo = result;
+    if (hi != (lo >> 31)) 
+        result = result2;
+    return result; 
+}
+
+static inline varying int32 saturating_mul(varying int32 a, varying int32 b) {
+    varying int64 result = (varying int64) a * (varying int64) b;	
+    varying unsigned int32 result2 = ((varying unsigned int32) (a ^ b) >> 31) + INT32_MAX;
+    varying int32 hi = result >> 32;
+    varying int32 lo = result;
+    if (hi != (lo >> 31)) 
+        result = result2;
+    return result; 
+}
+
+static inline uniform unsigned int8 saturating_mul(uniform unsigned int8 a,
+                                                   uniform unsigned int8 b) {
+    uniform unsigned int16 result = (uniform unsigned int16) a * 
+                                    (uniform unsigned int16) b;
+    uniform unsigned int8 hi = result >> 8;
+    uniform unsigned int8 lo = result;
+    return lo | - (uniform int8) !! hi;
+}
+
+static inline varying unsigned int8 saturating_mul(varying unsigned int8 a,
+                                                   varying unsigned int8 b) {
+    varying unsigned int16 result = (varying unsigned int16) a * 
+                                    (varying unsigned int16) b;
+    varying unsigned int8 hi = result >> 8;
+    varying unsigned int8 lo = result;
+    return lo | - (varying int8) !! hi;
+}
+
+static inline uniform unsigned int16 saturating_mul(uniform unsigned int16 a,
+                                                    uniform unsigned int16 b) {
+    uniform unsigned int32 result = (uniform unsigned int32) a * 
+                                    (uniform unsigned int32) b;
+    uniform unsigned int16 hi = result >> 16;
+    uniform unsigned int16 lo = result;
+    return lo | - (uniform int16) !! hi;
+}
+
+static inline varying unsigned int16 saturating_mul(varying unsigned int16 a,
+                                                    varying unsigned int16 b) {
+    varying unsigned int32 result = (varying unsigned int32) a * 
+                                    (varying unsigned int32) b;
+    varying unsigned int16 hi = result >> 16;
+    varying unsigned int16 lo = result;
+    return lo | - (varying int16) !! hi;
+}
+
+static inline uniform unsigned int32 saturating_mul(uniform unsigned int32 a,
+                                                    uniform unsigned int32 b) {
+    uniform unsigned int64 result = (uniform unsigned int64) a * 
+                                    (uniform unsigned int64) b;
+    uniform unsigned int32 hi = result >> 32;
+    uniform unsigned int32 lo = result;
+    return lo | - (uniform int32) !! hi;
+}
+
+static inline varying unsigned int32 saturating_mul(varying unsigned int32 a,
+                                                    varying unsigned int32 b) {
+    varying unsigned int64 result = (varying unsigned int64) a * 
+                                    (varying unsigned int64) b;
+    varying unsigned int32 hi = result >> 32;
+    varying unsigned int32 lo = result;
+    return lo | - (varying int32) !! hi;
+}
 ///////////////////////////////////////////////////////////////////////////
 // rdrand
 
diff --git a/tests/pdivs_i16.ispc b/tests/pdivs_i16.ispc
new file mode 100644
index 00000000..b9b5858f
--- /dev/null
+++ b/tests/pdivs_i16.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (uniform int16) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (uniform int16) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (uniform int16) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int16) 6553.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int16) -6553.6;
+    }
+    else {
+        RET[programIndex] = (uniform int16) 32767;
+    } 
+}
diff --git a/tests/pdivs_i32.ispc b/tests/pdivs_i32.ispc
new file mode 100644
index 00000000..99760828
--- /dev/null
+++ b/tests/pdivs_i32.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (uniform int32) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (uniform int32) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (uniform int32) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int32) 429496729.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int32) -429496729.6;
+    }
+    else {
+        RET[programIndex] = (uniform int32) 2147483647;
+    } 
+}
diff --git a/tests/pdivs_i64.ispc b/tests/pdivs_i64.ispc
new file mode 100644
index 00000000..e0de47f7
--- /dev/null
+++ b/tests/pdivs_i64.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (uniform int64) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (uniform int64) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (uniform int64) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int64) 1844674407370955161.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int64) -1844674407370955161.6;
+    }
+    else {
+        RET[programIndex] = (uniform int64) 9223372036854775807;
+    } 
+}
diff --git a/tests/pdivs_i8.ispc b/tests/pdivs_i8.ispc
new file mode 100644
index 00000000..c68dcd64
--- /dev/null
+++ b/tests/pdivs_i8.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (uniform int8) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (uniform int8) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (uniform int8) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int8) 25.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int8) -25.6;
+    }
+    else {
+        RET[programIndex] = (uniform int8) 127;
+    } 
+}
diff --git a/tests/pdivs_vi16.ispc b/tests/pdivs_vi16.ispc
new file mode 100644
index 00000000..0b119672
--- /dev/null
+++ b/tests/pdivs_vi16.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (varying int16) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (varying int16) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (varying int16) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int16) 6553.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int16) -6553.6;
+    }
+    else {
+        RET[programIndex] = (varying int16) 32767;
+    } 
+}
diff --git a/tests/pdivs_vi32.ispc b/tests/pdivs_vi32.ispc
new file mode 100644
index 00000000..4f6b0bae
--- /dev/null
+++ b/tests/pdivs_vi32.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (varying int32) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (varying int32) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (varying int32) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int32) 429496729.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int32) -429496729.6;
+    }
+    else {
+        RET[programIndex] = (varying int32) 2147483647;
+    } 
+}
diff --git a/tests/pdivs_vi64.ispc b/tests/pdivs_vi64.ispc
new file mode 100644
index 00000000..cb4fba70
--- /dev/null
+++ b/tests/pdivs_vi64.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (varying int64) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (varying int64) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (varying int64) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int64) 1844674407370955161.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int64) -1844674407370955161.6;
+    }
+    else {
+        RET[programIndex] = (varying int64) 9223372036854775807;
+    } 
+}
diff --git a/tests/pdivs_vi8.ispc b/tests/pdivs_vi8.ispc
new file mode 100644
index 00000000..7b021645
--- /dev/null
+++ b/tests/pdivs_vi8.ispc
@@ -0,0 +1,27 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_div(a_max, (varying int8) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_div(a_min, (varying int8) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_min, (varying int8) -1);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int8) 25.4;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int8) -25.6;
+    }
+    else {
+        RET[programIndex] = (varying int8) 127;
+    } 
+}
diff --git a/tests/pdivus_i16.ispc b/tests/pdivus_i16.ispc
new file mode 100644
index 00000000..827eedfc
--- /dev/null
+++ b/tests/pdivus_i16.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (uniform unsigned int16) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (uniform unsigned int16) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (uniform unsigned int16) 0;
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int16) 13107;
+    } 
+}
diff --git a/tests/pdivus_i32.ispc b/tests/pdivus_i32.ispc
new file mode 100644
index 00000000..ec4c97be
--- /dev/null
+++ b/tests/pdivus_i32.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (uniform unsigned int32) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (uniform unsigned int32) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (uniform unsigned int32) 0;
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int32) 858993459;
+    } 
+}
diff --git a/tests/pdivus_i64.ispc b/tests/pdivus_i64.ispc
new file mode 100644
index 00000000..ddc4d866
--- /dev/null
+++ b/tests/pdivus_i64.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (uniform unsigned int64) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (uniform unsigned int64) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (uniform unsigned int64) 0;
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int64) 3689348814741910323;
+    } 
+}
diff --git a/tests/pdivus_i8.ispc b/tests/pdivus_i8.ispc
new file mode 100644
index 00000000..0c133a1d
--- /dev/null
+++ b/tests/pdivus_i8.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (uniform unsigned int8) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (uniform unsigned int8) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (uniform unsigned int8) 0;
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int8) 51;
+    } 
+}
diff --git a/tests/pdivus_vi16.ispc b/tests/pdivus_vi16.ispc
new file mode 100644
index 00000000..754399db
--- /dev/null
+++ b/tests/pdivus_vi16.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (varying unsigned int16) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (varying unsigned int16) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (varying unsigned int16) 0;
+    }
+    else {
+        RET[programIndex] = (varying unsigned int16) 13107;
+    } 
+}
diff --git a/tests/pdivus_vi32.ispc b/tests/pdivus_vi32.ispc
new file mode 100644
index 00000000..3d6172db
--- /dev/null
+++ b/tests/pdivus_vi32.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (varying unsigned int32) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (varying unsigned int32) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (varying unsigned int32) 0;
+    }
+    else {
+        RET[programIndex] = (varying unsigned int32) 858993459;
+    } 
+}
diff --git a/tests/pdivus_vi64.ispc b/tests/pdivus_vi64.ispc
new file mode 100644
index 00000000..e7e8ca20
--- /dev/null
+++ b/tests/pdivus_vi64.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (varying unsigned int64) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (varying unsigned int64) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (varying unsigned int64) 0;
+    }
+    else {
+        RET[programIndex] = (varying unsigned int64) 3689348814741910323;
+    } 
+}
diff --git a/tests/pdivus_vi8.ispc b/tests/pdivus_vi8.ispc
new file mode 100644
index 00000000..7bcd7f1d
--- /dev/null
+++ b/tests/pdivus_vi8.ispc
@@ -0,0 +1,21 @@
+
+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
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_div(a_min, (varying unsigned int8) b);
+    }
+    else {
+        RET[programIndex] = saturating_div(a_max, (varying unsigned int8) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (varying unsigned int8) 0;
+    }
+    else {
+        RET[programIndex] = (varying unsigned int8) 51;
+    } 
+}
diff --git a/tests/pmuls_i16.ispc b/tests/pmuls_i16.ispc
new file mode 100644
index 00000000..f7e58a7f
--- /dev/null
+++ b/tests/pmuls_i16.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (uniform int16) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (uniform int16) b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((uniform int16) b,
+                                           (uniform int16) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int16) 32767;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int16) -32768;
+    }
+    else {
+        RET[programIndex] = (uniform int16) 25;
+    } 
+}
diff --git a/tests/pmuls_i32.ispc b/tests/pmuls_i32.ispc
new file mode 100644
index 00000000..aca6324d
--- /dev/null
+++ b/tests/pmuls_i32.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (uniform int32) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (uniform int32) b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((uniform int32) b,
+                                           (uniform int32) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int32) 2147483647;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int32) -2147483648;
+    }
+    else {
+        RET[programIndex] = (uniform int32) 25;
+    } 
+}
diff --git a/tests/pmuls_i8.ispc b/tests/pmuls_i8.ispc
new file mode 100644
index 00000000..0b14f5bb
--- /dev/null
+++ b/tests/pmuls_i8.ispc
@@ -0,0 +1,29 @@
+
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (uniform int8) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (uniform int8) b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((uniform int8) b,
+                                           (uniform int8) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int8) 127;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int8) -128;
+    }
+    else {
+        RET[programIndex] = (uniform int8) 25;
+    } 
+}
diff --git a/tests/pmuls_vi16.ispc b/tests/pmuls_vi16.ispc
new file mode 100644
index 00000000..b2f153e6
--- /dev/null
+++ b/tests/pmuls_vi16.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (varying int16) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (varying int16) b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((varying int16) b,
+                                           (varying int16) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int16) 32767;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int16) -32768;
+    }
+    else {
+        RET[programIndex] = (varying int16) 25;
+    } 
+}
diff --git a/tests/pmuls_vi32.ispc b/tests/pmuls_vi32.ispc
new file mode 100644
index 00000000..d4030e0d
--- /dev/null
+++ b/tests/pmuls_vi32.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (varying int32) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (varying int32) b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((varying int32) b,
+                                           (varying int32) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int32) 2147483647;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int32) -2147483648;
+    }
+    else {
+        RET[programIndex] = (varying int32) 25;
+    } 
+}
diff --git a/tests/pmuls_vi8.ispc b/tests/pmuls_vi8.ispc
new file mode 100644
index 00000000..d8da3465
--- /dev/null
+++ b/tests/pmuls_vi8.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (varying int8) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (varying int8) b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((varying int8) b,
+                                           (varying int8) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int8) 127;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int8) -128;
+    }
+    else {
+        RET[programIndex] = (varying int8) 25;
+    } 
+}
diff --git a/tests/pmulus_i16.ispc b/tests/pmulus_i16.ispc
new file mode 100644
index 00000000..b01a1acd
--- /dev/null
+++ b/tests/pmulus_i16.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (uniform unsigned int16) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (uniform unsigned int16) -b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((uniform unsigned int16) b,
+                                           (uniform unsigned int16) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform unsigned int16) 65535;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform unsigned int16) 0;
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int16) 25;
+    } 
+}
diff --git a/tests/pmulus_i32.ispc b/tests/pmulus_i32.ispc
new file mode 100644
index 00000000..d7116f12
--- /dev/null
+++ b/tests/pmulus_i32.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (uniform unsigned int32) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (uniform unsigned int32) -b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((uniform unsigned int32) b,
+                                           (uniform unsigned int32) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform unsigned int32) 4294967295;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform unsigned int32) 0;
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int32) 25;
+    } 
+}
diff --git a/tests/pmulus_i8.ispc b/tests/pmulus_i8.ispc
new file mode 100644
index 00000000..f70fe716
--- /dev/null
+++ b/tests/pmulus_i8.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (uniform unsigned int8) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (uniform unsigned int8) -b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((uniform unsigned int8) b,
+                                           (uniform unsigned int8) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform unsigned int8) 255;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform unsigned int8) 0;
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int8) 25;
+    } 
+}
diff --git a/tests/pmulus_vi16.ispc b/tests/pmulus_vi16.ispc
new file mode 100644
index 00000000..256c0365
--- /dev/null
+++ b/tests/pmulus_vi16.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (varying unsigned int16) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (varying unsigned int16) -b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((varying unsigned int16) b,
+                                           (varying unsigned int16) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying unsigned int16) 65535;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying unsigned int16) 0;
+    }
+    else {
+        RET[programIndex] = (varying unsigned int16) 25;
+    } 
+}
diff --git a/tests/pmulus_vi32.ispc b/tests/pmulus_vi32.ispc
new file mode 100644
index 00000000..b109d2cf
--- /dev/null
+++ b/tests/pmulus_vi32.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (varying unsigned int32) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (varying unsigned int32) -b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((varying unsigned int32) b,
+                                           (varying unsigned int32) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying unsigned int32) 4294967295;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying unsigned int32) 0;
+    }
+    else {
+        RET[programIndex] = (varying unsigned int32) 25;
+    } 
+}
diff --git a/tests/pmulus_vi8.ispc b/tests/pmulus_vi8.ispc
new file mode 100644
index 00000000..1dc46697
--- /dev/null
+++ b/tests/pmulus_vi8.ispc
@@ -0,0 +1,28 @@
+
+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
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_mul(a_max, (varying unsigned int8) b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_mul(a_min, (varying unsigned int8) -b);
+    }
+    else {
+        RET[programIndex] = saturating_mul((varying unsigned int8) b,
+                                           (varying unsigned int8) b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying unsigned int8) 255;
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying unsigned int8) 0;
+    }
+    else {
+        RET[programIndex] = (varying unsigned int8) 25;
+    } 
+}