diff --git a/module.cpp b/module.cpp
index 1a19e10c..25db0fed 100644
--- a/module.cpp
+++ b/module.cpp
@@ -2048,9 +2048,6 @@ void
 Module::execPreprocessor(const char *infilename, llvm::raw_string_ostream *ostream) const
 {
     clang::CompilerInstance inst;
-#if defined(LLVM_3_5)
-    inst.createVirtualFileSystem();
-#endif
     inst.createFileManager();
 
     llvm::raw_fd_ostream stderrRaw(2, false);
diff --git a/opt.cpp b/opt.cpp
index 4f945c4b..19ce8386 100644
--- a/opt.cpp
+++ b/opt.cpp
@@ -1335,12 +1335,24 @@ char ImproveMemoryOpsPass::ID = 0;
  */
 static llvm::Value *
 lCheckForActualPointer(llvm::Value *v) {
-    if (v == NULL)
+    if (v == NULL) {
         return NULL;
-    else if (llvm::isa<llvm::PointerType>(v->getType()))
+    }
+    else if (llvm::isa<llvm::PointerType>(v->getType())) {
         return v;
-    else if (llvm::isa<llvm::PtrToIntInst>(v))
+    }
+    else if (llvm::isa<llvm::PtrToIntInst>(v)) {
         return v;
+    }
+    else if (llvm::CastInst *ci = llvm::dyn_cast<llvm::CastInst>(v)) {
+        llvm::Value *t = lCheckForActualPointer(ci->getOperand(0));
+        if (t == NULL) {
+            return NULL;
+        }
+        else {
+            return v;
+        }
+    }
     else {
         llvm::ConstantExpr *uce =
             llvm::dyn_cast<llvm::ConstantExpr>(v);
@@ -1358,7 +1370,7 @@ lCheckForActualPointer(llvm::Value *v) {
     pointer value; otherwise it returns NULL.
  */
 static llvm::Value *
-lGetBasePointer(llvm::Value *v) {
+lGetBasePointer(llvm::Value *v, llvm::Instruction *insertBefore) {
     if (llvm::isa<llvm::InsertElementInst>(v) ||
         llvm::isa<llvm::ShuffleVectorInst>(v)) {
         llvm::Value *element = LLVMFlattenInsertChain
@@ -1382,6 +1394,20 @@ lGetBasePointer(llvm::Value *v) {
     else if (llvm::ConstantDataVector *cdv = llvm::dyn_cast<llvm::ConstantDataVector>(v)) {
         return lCheckForActualPointer(cdv->getSplatValue());
     }
+    // It is a little bit tricky to use operations with pointers, casted to int with another bit size
+    // but sometimes it is useful, so we handle this case here.
+    else if (llvm::CastInst *ci = llvm::dyn_cast<llvm::CastInst>(v)) {
+        llvm::Value *t = lGetBasePointer(ci->getOperand(0), insertBefore);
+        if (t == NULL) {
+            return NULL;
+        }
+        else {
+            return llvm::CastInst::Create(ci->getOpcode(),
+                                              t, ci->getType()->getScalarType(),
+                                              LLVMGetName(t, "_cast"),
+                                              insertBefore);
+        }
+    }
 
     return NULL;
 }
@@ -1435,7 +1461,7 @@ lGetBasePtrAndOffsets(llvm::Value *ptrs, llvm::Value **offsets,
         LLVMDumpValue(ptrs);
     }
 
-    llvm::Value *base = lGetBasePointer(ptrs);
+    llvm::Value *base = lGetBasePointer(ptrs, insertBefore);
     if (base != NULL) {
         // We have a straight up varying pointer with no indexing that's
         // actually all the same value.
@@ -1571,30 +1597,30 @@ lExtractConstantOffset(llvm::Value *vec, llvm::Value **constOffset,
         return;
     }
 
-    llvm::SExtInst *sext = llvm::dyn_cast<llvm::SExtInst>(vec);
-    if (sext != NULL) {
-        // Check the sext target.
+    llvm::CastInst *cast = llvm::dyn_cast<llvm::CastInst>(vec);
+    if (cast != NULL) {
+        // Check the cast target.
         llvm::Value *co, *vo;
-        lExtractConstantOffset(sext->getOperand(0), &co, &vo, insertBefore);
+        lExtractConstantOffset(cast->getOperand(0), &co, &vo, insertBefore);
 
-        // make new sext instructions for the two parts
+        // make new cast instructions for the two parts
         if (co == NULL)
             *constOffset = NULL;
         else
-            *constOffset = new llvm::SExtInst(co, sext->getType(),
-                                              LLVMGetName(co, "_sext"),
+            *constOffset = llvm::CastInst::Create(cast->getOpcode(),
+                                              co, cast->getType(),
+                                              LLVMGetName(co, "_cast"),
                                               insertBefore);
         if (vo == NULL)
             *variableOffset = NULL;
         else
-            *variableOffset = new llvm::SExtInst(vo, sext->getType(),
-                                                 LLVMGetName(vo, "_sext"),
+            *variableOffset = llvm::CastInst::Create(cast->getOpcode(),
+                                                 vo, cast->getType(),
+                                                 LLVMGetName(vo, "_cast"),
                                                  insertBefore);
         return;
     }
 
-    // FIXME? handle bitcasts / type casts here
-
     llvm::BinaryOperator *bop = llvm::dyn_cast<llvm::BinaryOperator>(vec);
     if (bop != NULL) {
         llvm::Value *op0 = bop->getOperand(0);
@@ -1786,17 +1812,17 @@ lExtract248Scale(llvm::Value *splatOperand, int splatValue,
  */
 static llvm::Value *
 lExtractOffsetVector248Scale(llvm::Value **vec) {
-    llvm::SExtInst *sext = llvm::dyn_cast<llvm::SExtInst>(*vec);
-    if (sext != NULL) {
-        llvm::Value *sextOp = sext->getOperand(0);
-        // Check the sext target.
-        llvm::Value *scale = lExtractOffsetVector248Scale(&sextOp);
+    llvm::CastInst *cast = llvm::dyn_cast<llvm::CastInst>(*vec);
+    if (cast != NULL) {
+        llvm::Value *castOp = cast->getOperand(0);
+        // Check the cast target.
+        llvm::Value *scale = lExtractOffsetVector248Scale(&castOp);
         if (scale == NULL)
             return NULL;
 
-        // make a new sext instruction so that we end up with the right
+        // make a new cast instruction so that we end up with the right
         // type
-        *vec = new llvm::SExtInst(sextOp, sext->getType(), "offset_sext", sext);
+        *vec = llvm::CastInst::Create(cast->getOpcode(), castOp, cast->getType(), "offset_cast", cast);
         return scale;
     }
 
diff --git a/stdlib.ispc b/stdlib.ispc
index dbf9b7e1..04d6f791 100644
--- a/stdlib.ispc
+++ b/stdlib.ispc
@@ -4595,6 +4595,42 @@ static inline varying int16 saturating_add(varying int16 a, varying int16 b) {
     return __padds_vi16(a, b);
 }
 
+static inline uniform int32 saturating_add(uniform int32 a, uniform int32 b) {
+    uniform unsigned int32 a_unsig = a, b_unsig = b;
+    uniform unsigned int32 result = a_unsig + b_unsig;
+    a_unsig = (a_unsig >> 31) + INT32_MAX;
+    if ((uniform int32) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
+        result = a_unsig;
+    return result;
+}
+
+static inline varying int32 saturating_add(varying int32 a, varying int32 b) {
+    varying unsigned int32 a_unsig = a, b_unsig = b;
+    varying unsigned int32 result = a_unsig + b_unsig;
+    a_unsig = (a_unsig >> 31) + INT32_MAX;
+    if ((varying int32) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
+        result = a_unsig;
+    return result;
+}
+
+static inline uniform int64 saturating_add(uniform int64 a, uniform int64 b) {
+    uniform unsigned int64 a_unsig = a, b_unsig = b;
+    uniform unsigned int64 result = a_unsig + b_unsig;
+    a_unsig = (a_unsig >> 63) + INT64_MAX;
+    if ((uniform int64) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
+        result = a_unsig;
+    return result;
+}
+
+static inline varying int64 saturating_add(varying int64 a, varying int64 b) {
+    varying unsigned int64 a_unsig = a, b_unsig = b;
+    varying unsigned int64 result = a_unsig + b_unsig;
+    a_unsig = (a_unsig >> 63) + INT64_MAX;
+    if ((varying int64) ((a_unsig ^ b_unsig) | ~(b_unsig ^ result)) >= 0)
+        result = a_unsig;
+    return result;
+}
+
 static inline uniform unsigned int8 saturating_add(uniform unsigned int8 a, 
                                                    uniform unsigned int8 b) {
     uniform unsigned int8 result = a + b;
@@ -4619,6 +4655,34 @@ static inline varying unsigned int16 saturating_add(varying unsigned int16 a,
     return __paddus_vi16(a, b);
 }
 
+static inline uniform unsigned int32 saturating_add(uniform unsigned int32 a, 
+                                                    uniform unsigned int32 b) {
+    uniform unsigned int32 result = a + b;
+    result |= (-(uniform int32)(result < a));
+    return result;
+}
+
+static inline varying unsigned int32 saturating_add(varying unsigned int32 a, 
+                                                    varying unsigned int32 b) {
+    varying unsigned int32 result = a + b;
+    result |= (-(varying int32)(result < a));
+    return result;
+}
+
+static inline uniform unsigned int64 saturating_add(uniform unsigned int64 a, 
+                                                    uniform unsigned int64 b) {
+    uniform unsigned int64 result = a + b;
+    result |= (-(uniform int64)(result < a));
+    return result;
+}
+
+static inline varying unsigned int64 saturating_add(varying unsigned int64 a, 
+                                                    varying unsigned int64 b) {
+    varying unsigned int64 result = a + b;
+    result |= (-(varying int64)(result < a));
+    return result;
+}
+
 static inline uniform int8 saturating_sub(uniform int8 a, uniform int8 b) {
     uniform unsigned int8 a_unsig = a, b_unsig = b;
     uniform unsigned int8 result = a_unsig - b_unsig;
@@ -4645,6 +4709,42 @@ static inline varying int16 saturating_sub(varying int16 a, varying int16 b) {
     return __psubs_vi16(a, b);
 }
 
+static inline uniform int32 saturating_sub(uniform int32 a, uniform int32 b) {
+    uniform unsigned int32 a_unsig = a, b_unsig = b;
+    uniform unsigned int32 result = a_unsig - b_unsig;
+    a_unsig = (a_unsig >> 31) + INT32_MAX;
+    if ((uniform int32) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
+        result = a_unsig;
+    return result;
+}
+
+static inline varying int32 saturating_sub(varying int32 a, varying int32 b) {
+    varying unsigned int32 a_unsig = a, b_unsig = b;
+    varying unsigned int32 result = a_unsig - b_unsig;
+    a_unsig = (a_unsig >> 31) + INT32_MAX;
+    if ((varying int32) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
+        result = a_unsig;
+    return result;
+}
+
+static inline uniform int64 saturating_sub(uniform int64 a, uniform int64 b) {
+    uniform unsigned int64 a_unsig = a, b_unsig = b;
+    uniform unsigned int64 result = a_unsig - b_unsig;
+    a_unsig = (a_unsig >> 63) + INT64_MAX;
+    if ((uniform int64) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
+        result = a_unsig;
+    return result;
+}
+
+static inline varying int64 saturating_sub(varying int64 a, varying int64 b) {
+    varying unsigned int64 a_unsig = a, b_unsig = b;
+    varying unsigned int64 result = a_unsig - b_unsig;
+    a_unsig = (a_unsig >> 63) + INT64_MAX;
+    if ((varying int64) ((a_unsig ^ b_unsig) & (a_unsig ^ result)) < 0)
+        result = a_unsig;
+    return result;
+}
+
 static inline uniform unsigned int8 saturating_sub(uniform unsigned int8 a, 
                                                    uniform unsigned int8 b) {
     uniform unsigned int8 result = a - b;
@@ -4668,6 +4768,244 @@ static inline varying unsigned int16 saturating_sub(varying unsigned int16 a,
                                                     varying unsigned int16 b) {
     return __psubus_vi16(a, b);
 }
+
+static inline uniform unsigned int32 saturating_sub(uniform unsigned int32 a, 
+                                                    uniform unsigned int32 b) {
+    uniform unsigned int32 result = a - b;
+    result &= (-(uniform int32)(result <= a));
+    return result;
+}
+
+static inline varying unsigned int32 saturating_sub(varying unsigned int32 a, 
+                                                    varying unsigned int32 b) {
+    varying unsigned int32 result = a - b;
+    result &= (-(varying int32)(result <= a));
+    return result;
+}
+
+static inline uniform unsigned int64 saturating_sub(uniform unsigned int64 a, 
+                                                    uniform unsigned int64 b) {
+    uniform unsigned int64 result = a - b;
+    result &= (-(uniform int64)(result <= a));
+    return result;
+}
+
+static inline varying unsigned int64 saturating_sub(varying unsigned int64 a, 
+                                                    varying unsigned int64 b) {
+    varying unsigned int64 result = a - b;
+    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/padds_i32.ispc b/tests/padds_i32.ispc
new file mode 100644
index 00000000..866f8496
--- /dev/null
+++ b/tests/padds_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 = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_add(a_min, -b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
+    }
+    else {
+        RET[programIndex] = (uniform int32) -0x7FFFFFFB; // min + 5
+    } 
+}
diff --git a/tests/padds_i64.ispc b/tests/padds_i64.ispc
new file mode 100644
index 00000000..6b61b394
--- /dev/null
+++ b/tests/padds_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 = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_add(a_min, -b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64
+    }
+    else {
+        RET[programIndex] = (uniform int64) -0x7FFFFFFFFFFFFFFB; // min + 5
+    } 
+}
diff --git a/tests/padds_vi32.ispc b/tests/padds_vi32.ispc
new file mode 100644
index 00000000..a51bdad9
--- /dev/null
+++ b/tests/padds_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 = 0x7FFFFFFF, a_min = -0x80000000; // max and min signed int32
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_add(a_min, -b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int32) -0x80000000; // min signed int32
+    }
+    else {
+        RET[programIndex] = (varying int32) -0x7FFFFFFB; // min + 5
+    } 
+}
diff --git a/tests/padds_vi64.ispc b/tests/padds_vi64.ispc
new file mode 100644
index 00000000..9b577a79
--- /dev/null
+++ b/tests/padds_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 = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min signed int64
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_add(a_min, -b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64
+    }
+    else {
+        RET[programIndex] = (varying int64) -0x7FFFFFFFFFFFFFFB; // min + 5
+    } 
+}
diff --git a/tests/paddus_i32.ispc b/tests/paddus_i32.ispc
new file mode 100644
index 00000000..2a159340
--- /dev/null
+++ b/tests/paddus_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 = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        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
new file mode 100644
index 00000000..38b5c4fe
--- /dev/null
+++ b/tests/paddus_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 = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        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
new file mode 100644
index 00000000..555d9837
--- /dev/null
+++ b/tests/paddus_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 = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        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
new file mode 100644
index 00000000..cf99be72
--- /dev/null
+++ b/tests/paddus_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 = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_add(a_max, b);
+    }
+    else {
+        RET[programIndex] = saturating_add(a_min, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        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
new file mode 100644
index 00000000..7dede2a7
--- /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 = 0x7FFF, a_min = -0x8000; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int16) -6553.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (uniform int16) 0x7FFF; // max signed int16
+    } 
+}
diff --git a/tests/pdivs_i32.ispc b/tests/pdivs_i32.ispc
new file mode 100644
index 00000000..d6d1d97d
--- /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 = 0x7FFFFFFF, a_min = -0x80000000; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int32) -429496729.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
+    } 
+}
diff --git a/tests/pdivs_i64.ispc b/tests/pdivs_i64.ispc
new file mode 100644
index 00000000..4a3bb268
--- /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 = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int64) -1844674407370955161.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
+    } 
+}
diff --git a/tests/pdivs_i8.ispc b/tests/pdivs_i8.ispc
new file mode 100644
index 00000000..0fa71253
--- /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 = 0x7F, a_min = -0x80; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int8) -25.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (uniform int8) 0x7F; // max signed int8
+    } 
+}
diff --git a/tests/pdivs_vi16.ispc b/tests/pdivs_vi16.ispc
new file mode 100644
index 00000000..482fbfcb
--- /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 = 0x7FFF, a_min = -0x8000; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int16) -6553.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (varying int16) 0x7FFF; // max signed int16
+    } 
+}
diff --git a/tests/pdivs_vi32.ispc b/tests/pdivs_vi32.ispc
new file mode 100644
index 00000000..1c699b68
--- /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 = 0x7FFFFFFF, a_min = -0x80000000; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int32) -429496729.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
+    } 
+}
diff --git a/tests/pdivs_vi64.ispc b/tests/pdivs_vi64.ispc
new file mode 100644
index 00000000..00913ea3
--- /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 = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int64) -1844674407370955161.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
+    } 
+}
diff --git a/tests/pdivs_vi8.ispc b/tests/pdivs_vi8.ispc
new file mode 100644
index 00000000..3e039a01
--- /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 = 0x7F, a_min = -0x80; // 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; // max / 5
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int8) -25.6; // min / 5 
+    }
+    else {
+        RET[programIndex] = (varying int8) 0x7F; // max signed int8
+    } 
+}
diff --git a/tests/pdivus_i16.ispc b/tests/pdivus_i16.ispc
new file mode 100644
index 00000000..c7573d78
--- /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 = 0xFFFF, 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; // min unsigned int16
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int16) 0x3333; // max unsigned int16 / 5
+    } 
+}
diff --git a/tests/pdivus_i32.ispc b/tests/pdivus_i32.ispc
new file mode 100644
index 00000000..c11b68fe
--- /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 = 0xFFFFFFFF, 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; // min unsigned int32
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int32) 0x33333333; // max unsigned int32 / 5
+    } 
+}
diff --git a/tests/pdivus_i64.ispc b/tests/pdivus_i64.ispc
new file mode 100644
index 00000000..51354ce7
--- /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 = 0xFFFFFFFFFFFFFFFF, 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; // min unsigned int64
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int64) 0x3333333333333333; // max unsigned int64 / 5
+    } 
+}
diff --git a/tests/pdivus_i8.ispc b/tests/pdivus_i8.ispc
new file mode 100644
index 00000000..1b509c30
--- /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 = 0xFF, 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; // min unsigned int8
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int8) 0x33; // max unsigned int8 / 5
+    } 
+}
diff --git a/tests/pdivus_vi16.ispc b/tests/pdivus_vi16.ispc
new file mode 100644
index 00000000..71696f7e
--- /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 = 0xFFFF, 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; // min unsigned int16
+    }
+    else {
+        RET[programIndex] = (varying unsigned int16) 0x3333; // max unsigned int16 / 5
+    } 
+}
diff --git a/tests/pdivus_vi32.ispc b/tests/pdivus_vi32.ispc
new file mode 100644
index 00000000..0c8a8f25
--- /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 = 0xFFFFFFFF, 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; // min unsigned int32
+    }
+    else {
+        RET[programIndex] = (varying unsigned int32) 0x33333333; // max unsigned int32 / 5
+    } 
+}
diff --git a/tests/pdivus_vi64.ispc b/tests/pdivus_vi64.ispc
new file mode 100644
index 00000000..1aef75f7
--- /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 = 0xFFFFFFFFFFFFFFFF, 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; // min unsigned int64
+    }
+    else {
+        RET[programIndex] = (varying unsigned int64) 0x3333333333333333; // max unsigned int64 / 5
+    } 
+}
diff --git a/tests/pdivus_vi8.ispc b/tests/pdivus_vi8.ispc
new file mode 100644
index 00000000..f4a5adaf
--- /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 = 0xFF, 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; // min unsigned int8
+    }
+    else {
+        RET[programIndex] = (varying unsigned int8) 0x33; // max unsigned int8 / 5
+    } 
+}
diff --git a/tests/pmuls_i16.ispc b/tests/pmuls_i16.ispc
new file mode 100644
index 00000000..38e8794f
--- /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 = 0x7FFF, a_min = -0x8000; // 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) 0x7FFF; // max signed int16
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..51a2f6ba
--- /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 = 0x7FFFFFFF, a_min = -0x80000000; // 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) 0x7FFFFFFF; // max signed int32
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..aa2419c7
--- /dev/null
+++ b/tests/pmuls_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 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);
+    }
+    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) 0x7F; // max signed int8
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..4d467b28
--- /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 = 0x7FFF, a_min = -0x8000; // 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) 0x7FFF; // max signed int16
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..00a178da
--- /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 = 0x7FFFFFFF, a_min = -0x80000000; // 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) 0x7FFFFFFF; // max signed int32
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..33975f51
--- /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 = 0x7F, a_min = -0x80; // 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) 0x7F; // max signed int8
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..bbf9182f
--- /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 = 0xFFFF, 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) 0xFFFF; // max unsigned int16
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..3f926d2d
--- /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 = 0xFFFFFFFF, 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) 0xFFFFFFFF; // max unsigned int32
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..71504ae3
--- /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 = 0xFF, 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) 0xFF; // max unsigned int8
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..427bf632
--- /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 = 0xFFFF, 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) 0xFFFF; // max unsigned int16
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..0e5a09b3
--- /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 = 0xFFFFFFFF, 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) 0xFFFFFFFF; // max unsigned int32
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..d378ee52
--- /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 = 0xFF, 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) 0xFF; // max unsigned int8
+    }
+    else if (programIndex % 3 == 1) {
+        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
new file mode 100644
index 00000000..7b4bad63
--- /dev/null
+++ b/tests/psubs_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 = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_sub(a_max, -b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int32) -0x80000000; // min signed int32
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int32) 0x7FFFFFFF; // max signed int32
+    }
+    else {
+        RET[programIndex] = (uniform int32) 0x7FFFFFFA;
+    } 
+}
diff --git a/tests/psubs_i64.ispc b/tests/psubs_i64.ispc
new file mode 100644
index 00000000..dd7b5715
--- /dev/null
+++ b/tests/psubs_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 = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_sub(a_max, -b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (uniform int64) -0x8000000000000000; // min signed int64
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
+    }
+    else {
+        RET[programIndex] = (uniform int64) 0x7FFFFFFFFFFFFFFA;
+    } 
+}
diff --git a/tests/psubs_vi32.ispc b/tests/psubs_vi32.ispc
new file mode 100644
index 00000000..6c3800ec
--- /dev/null
+++ b/tests/psubs_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 = 0x7FFFFFFF, a_min = -0x80000000; // max and min int32
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_sub(a_max, -b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int32) -0x80000000; // min signed int32
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int32) 0x7FFFFFFF; // max signed int32
+    }
+    else {
+        RET[programIndex] = (varying int32) 0x7FFFFFFA;
+    } 
+}
diff --git a/tests/psubs_vi64.ispc b/tests/psubs_vi64.ispc
new file mode 100644
index 00000000..887134b4
--- /dev/null
+++ b/tests/psubs_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 = 0x7FFFFFFFFFFFFFFF, a_min = -0x8000000000000000; // max and min int64
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = saturating_sub(a_max, -b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 3 == 0) {
+        RET[programIndex] = (varying int64) -0x8000000000000000; // min signed int64
+    }
+    else if (programIndex % 3 == 1) {
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFF; // max signed int64
+    }
+    else {
+        RET[programIndex] = (varying int64) 0x7FFFFFFFFFFFFFFA;
+    } 
+}
diff --git a/tests/psubus_i32.ispc b/tests/psubus_i32.ispc
new file mode 100644
index 00000000..a3352d5d
--- /dev/null
+++ b/tests/psubus_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 = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (uniform unsigned int32) 0; // min unsigned int32
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5
+    } 
+}
diff --git a/tests/psubus_i64.ispc b/tests/psubus_i64.ispc
new file mode 100644
index 00000000..d1a6ee51
--- /dev/null
+++ b/tests/psubus_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 = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (uniform unsigned int64) 0; // min unsigned int64
+    }
+    else {
+        RET[programIndex] = (uniform unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5
+    } 
+}
diff --git a/tests/psubus_vi32.ispc b/tests/psubus_vi32.ispc
new file mode 100644
index 00000000..22a42963
--- /dev/null
+++ b/tests/psubus_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 = 0xFFFFFFFF, a_min = 0; // max and min unsigned int32
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (varying unsigned int32) 0; // min unsigned int32
+    }
+    else {
+        RET[programIndex] = (varying unsigned int32) 0xFFFFFFFB; // max unsigned int32 - 5
+    } 
+}
diff --git a/tests/psubus_vi64.ispc b/tests/psubus_vi64.ispc
new file mode 100644
index 00000000..870d468a
--- /dev/null
+++ b/tests/psubus_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 = 0xFFFFFFFFFFFFFFFF, a_min = 0; // max and min unsigned int64
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = saturating_sub(a_min, b);
+    }
+    else {
+        RET[programIndex] = saturating_sub(a_max, b);
+    } 
+}
+
+export void result(uniform float RET[]) {
+    if (programIndex % 2 == 0) {
+        RET[programIndex] = (varying unsigned int64) 0; // min unsigned int64
+    }
+    else {
+        RET[programIndex] = (varying unsigned int64) 0xFFFFFFFFFFFFFFFB; // max unsigned int64 - 5
+    } 
+}
diff --git a/tests/ptr-int-1.ispc b/tests/ptr-int-1.ispc
index 1ffbc02f..cdcb8807 100644
--- a/tests/ptr-int-1.ispc
+++ b/tests/ptr-int-1.ispc
@@ -5,7 +5,7 @@ export uniform int width() { return programCount; }
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     uniform int a = 1;
     uniform int * uniform b = &a;
-    int64 pi = (int64)b;
+    uintptr_t pi = (uintptr_t)b;
     RET[programIndex] = *((uniform int * varying)pi);
 }