Merge "Flesh out reduction support for half data types."

20 files changed, 11348 insertions, 148 deletions

diff --git a/slang_rs_export_reduce.cpp b/slang_rs_export_reduce.cpp
index 0e973bd..52538bb 100644
--- a/slang_rs_export_reduce.cpp
+++ b/slang_rs_export_reduce.cpp
@@ -889,20 +889,6 @@ void RSExportReduceNew::analyzeResultType(StateOfAnalyzeTranslationUnit &S) {
               << ResultInfo.UnlessOutConverter();
           mResultType = nullptr;
           break;
-        case RSExportType::ExportClassVector: {
-          const RSExportVectorType *const EVT = static_cast<const RSExportVectorType *>(CheckType);
-          if (EVT->getType() == DataTypeFloat16) {
-            // Not supported for now -- how is this handled?
-            S.RSC.ReportError(ResultInfo.Decl->getLocation(),
-                              "%0 parameter '%1' (type '%2') must not point to a%3 half* vector%4")
-                << S.DiagnosticDescription(ResultInfo.FnKey, ResultInfo.FnName)
-                << ResultInfo.Decl->getName() << ResultInfo.QType.getAsString()
-                << ArrayErrorPhrase
-                << ResultInfo.UnlessOutConverter();
-            mResultType = nullptr;
-          }
-          break;
-        }
         default:
           // All's well
           break;
diff --git a/slang_rs_export_type.cpp b/slang_rs_export_type.cpp
index f79db7a..cf5e71c 100644
--- a/slang_rs_export_type.cpp
+++ b/slang_rs_export_type.cpp
@@ -61,7 +61,7 @@ namespace {
 static RSReflectionType gReflectionTypes[] = {
 #define _ nullptr
   //      Category     SName              RsType       RsST           CName         JN      JAEN       CVN       JVN     JP
-{PrimitiveDataType,   "half",         "FLOAT_16",     "F16", 16,     "half",   "short",        _,   "Half",   "Half", false},
+{PrimitiveDataType,   "half",         "FLOAT_16",     "F16", 16,     "half",   "short",  "short",   "Half",  "Short", false},
 {PrimitiveDataType,  "float",         "FLOAT_32",     "F32", 32,    "float",   "float",  "float",  "Float",  "Float", false},
 {PrimitiveDataType, "double",         "FLOAT_64",     "F64", 64,   "double",  "double", "double", "Double", "Double", false},
 {PrimitiveDataType,   "char",         "SIGNED_8",      "I8",  8,   "int8_t",    "byte",   "byte",   "Byte",   "Byte", false},
diff --git a/slang_rs_reflection.cpp b/slang_rs_reflection.cpp
index 97d7a87..8b422be 100644
--- a/slang_rs_reflection.cpp
+++ b/slang_rs_reflection.cpp
@@ -1366,6 +1366,7 @@ void RSReflectionJava::genExportReduceNewArrayVariant(const RSExportReduceNew *E
   ResultType->convertToRTD(&ResultTypeData);
   if (!ResultTypeData.type->java_name || !ResultTypeData.type->java_array_element_name ||
       (ResultTypeData.vecSize > 1 && !ResultTypeData.type->rs_java_vector_prefix)) {
+    slangAssert(false);
     return;
   }
   const std::string ResultTypeName = GetReduceNewResultTypeName(ER);
@@ -1640,7 +1641,7 @@ void RSReflectionJava::genExportReduceNewResultType(const RSExportType *ResultTy
   const std::string UnbracketedResultTypeName =
       GetTypeName(ResultType, TypeNameDefault & ~TypeNameWithConstantArrayBrackets);
   const std::string ReflectedScalarTypeName = TypeData.type->java_name;
-  // Note: MATRIX* and F16 types do not have a java_array_element_name
+  // Note: MATRIX* types do not have a java_array_element_name
   const std::string ArrayElementTypeName =
       TypeData.type->java_array_element_name
       ? std::string(TypeData.type->java_array_element_name)
diff --git a/tests/F_reduce_general_bad_function/reduce_general_bad_function.rs b/tests/F_reduce_general_bad_function/reduce_general_bad_function.rs
index 36b323e..8287696 100644
--- a/tests/F_reduce_general_bad_function/reduce_general_bad_function.rs
+++ b/tests/F_reduce_general_bad_function/reduce_general_bad_function.rs
@@ -230,7 +230,7 @@ static void ova_out(int *out, const double *val) { }
 #pragma rs reduce(out_over) accumulator(AccumInt) outconverter(out_over)
 static __attribute__((overloadable)) void out_over(double *accum, const int *val) { }
 
-// . . . but outconverter  must not have duplicate definitions
+// . . . but outconverter must not have duplicate definitions
 #pragma rs reduce(out_dup) accumulator(AccumInt) outconverter(out_dup)
 static __attribute__((overloadable)) void out_dup(double *out, const int *val) { }
 static __attribute__((overloadable)) void out_dup(float *out, const int *val) { }
diff --git a/tests/F_reduce_general_bad_result/reduce_general_bad_result.rs b/tests/F_reduce_general_bad_result/reduce_general_bad_result.rs
index 7c1fdc9..ab4283d 100644
--- a/tests/F_reduce_general_bad_result/reduce_general_bad_result.rs
+++ b/tests/F_reduce_general_bad_result/reduce_general_bad_result.rs
@@ -15,38 +15,6 @@ static void AccumInt(int *accum, int val) { }
 
 /////////////////////////////////////////////////////////////////////////
 
-// result type cannot be a vector of half
-#pragma rs reduce(redHalf3) accumulator(AccumHalf3)
-static void AccumHalf3(half3 *accum, half3 val) { }
-
-// problem is result type, not accumulator type, so outconverter can fix this
-#pragma rs reduce(redHalf3OutFix) accumulator(AccumHalf3) outconverter(OutHalf3Fix)
-static void OutHalf3Fix(half *out, const half3 *val) { }
-
-// problem is result type, not accumulator type, so outconverter can break this
-#pragma rs reduce(redHalf3OutBreak) accumulator(AccumInt) outconverter(OutHalf3Break)
-static void OutHalf3Break(half3 *out, const int *val) { }
-
-/////////////////////////////////////////////////////////////////////////
-
-typedef half4 Half4Array5[5];
-
-// result type cannot be an array of vector of half
-#pragma rs reduce(redHalf4A5) accumulator(AccumHalf4A5) combiner(CombHalf4A5)
-static void AccumHalf4A5(Half4Array5 *accum, short val) { }
-static void CombHalf4A5(Half4Array5 *accum, const Half4Array5 *other) { }
-
-// problem is result type, not accumulator type, so outconverter can fix this
-#pragma rs reduce(redHalf4A5OutFix) accumulator(AccumHalf4A5) combiner(CombHalf4A5) \
-  outconverter(OutHalf4A5Fix)
-static void OutHalf4A5Fix(half *out, const Half4Array5 *val) { }
-
-// problem is result type, not accumulator type, so outconverter can break this
-#pragma rs reduce(redHalf4A5OutBreak) accumulator(AccumInt) outconverter(OutHalf4A5Break)
-static void OutHalf4A5Break(Half4Array5 *out, const int *val) { }
-
-/////////////////////////////////////////////////////////////////////////
-
 typedef unsigned int UIntA916[9][16];
 
 // result type cannot be multidimensional array
diff --git a/tests/F_reduce_general_bad_result/stderr.txt.expect b/tests/F_reduce_general_bad_result/stderr.txt.expect
index 2b4ce24..686ca1d 100644
--- a/tests/F_reduce_general_bad_result/stderr.txt.expect
+++ b/tests/F_reduce_general_bad_result/stderr.txt.expect
@@ -1,33 +1,29 @@
-reduce_general_bad_result.rs:20:31: error: accumulator AccumHalf3() for '#pragma rs reduce(redHalf3)' (reduce_general_bad_result.rs:19:12) parameter 'accum' (type '__fp16 * __attribute__((ext_vector_type(3)))') must not point to a half* vector unless outconverter is provided
-reduce_general_bad_result.rs:28:34: error: outconverter OutHalf3Break() for '#pragma rs reduce(redHalf3OutBreak)' (reduce_general_bad_result.rs:27:12) parameter 'out' (type '__fp16 * __attribute__((ext_vector_type(3)))') must not point to a half* vector
-reduce_general_bad_result.rs:36:39: error: accumulator AccumHalf4A5() for '#pragma rs reduce(redHalf4A5)' (reduce_general_bad_result.rs:35:12) parameter 'accum' (type '__fp16 (*)[5] __attribute__((ext_vector_type(4)))') must not point to an array of half* vector unless outconverter is provided
-reduce_general_bad_result.rs:46:42: error: outconverter OutHalf4A5Break() for '#pragma rs reduce(redHalf4A5OutBreak)' (reduce_general_bad_result.rs:45:12) parameter 'out' (type '__fp16 (*)[5] __attribute__((ext_vector_type(4)))') must not point to an array of half* vector
-reduce_general_bad_result.rs:54:36: error: multidimensional arrays cannot be exported: 'accum'
-reduce_general_bad_result.rs:64:39: error: multidimensional arrays cannot be exported: 'out'
-reduce_general_bad_result.rs:68:7: error: unions cannot be exported: 'UnionShortDouble'
-reduce_general_bad_result.rs:78:7: error: unions cannot be exported: 'UnionLongFloat'
-reduce_general_bad_result.rs:104:7: error: unions cannot be exported: 'UnionIntFloat'
-reduce_general_bad_result.rs:116:7: error: unions cannot be exported: 'UnionCharLong'
-reduce_general_bad_result.rs:145:7: error: bit fields are not able to be exported: 'Bits1.b'
-reduce_general_bad_result.rs:154:7: error: bit fields are not able to be exported: 'Bits111.e'
-reduce_general_bad_result.rs:178:7: error: bit fields are not able to be exported: 'Bits2.b'
-reduce_general_bad_result.rs:189:7: error: bit fields are not able to be exported: 'Bits222.e'
-reduce_general_bad_result.rs:215:36: error: accumulator AccumMat() for '#pragma rs reduce(redMat)' (reduce_general_bad_result.rs:214:12) parameter 'accum' (type 'rs_matrix2x2 *') must not point to a matrix type unless outconverter is provided
-reduce_general_bad_result.rs:223:39: error: outconverter OutMatBreak() for '#pragma rs reduce(redMatOutBreak)' (reduce_general_bad_result.rs:222:12) parameter 'out' (type 'rs_matrix2x2 *') must not point to a matrix type
-reduce_general_bad_result.rs:231:43: error: accumulator AccumMatArray() for '#pragma rs reduce(redMatArray)' (reduce_general_bad_result.rs:230:12) parameter 'accum' (type 'rs_matrix2x2 (*)[10]') must not point to an array of matrix type unless outconverter is provided
-reduce_general_bad_result.rs:241:46: error: outconverter OutMatArrayBreak() for '#pragma rs reduce(redMatArrayOutBreak)' (reduce_general_bad_result.rs:240:12) parameter 'out' (type 'rs_matrix2x2 (*)[10]') must not point to an array of matrix type
-reduce_general_bad_result.rs:247:37: error: outconverter OutAlloc() for '#pragma rs reduce(redAlloc)' (reduce_general_bad_result.rs:246:12) parameter 'out' (type 'struct rs_allocation *') must not point to data containing an object type
-reduce_general_bad_result.rs:256:39: error: outconverter OutAllocArray() for '#pragma rs reduce(redAllocArray)' (reduce_general_bad_result.rs:254:12) parameter 'out' (type 'struct rs_allocation (*)[10]') must not point to data containing an object type
-reduce_general_bad_result.rs:268:45: error: outconverter OutStructObj() for '#pragma rs reduce(redStructObj)' (reduce_general_bad_result.rs:266:12) parameter 'out' (type 'struct StructObj1 *') must not point to data containing an object type
-reduce_general_bad_result.rs:282:48: error: outconverter OutStructObjArray() for '#pragma rs reduce(redStructObjArray)' (reduce_general_bad_result.rs:279:12) parameter 'out' (type 'struct StructObj2 (*)[10]') must not point to data containing an object type
-reduce_general_bad_result.rs:290:27: error: accumulator AccumPtr() for '#pragma rs reduce(redPtr)' (reduce_general_bad_result.rs:289:12) parameter 'accum' (type 'char **') must not point to a pointer unless outconverter is provided
-reduce_general_bad_result.rs:300:30: error: outconverter OutPtrBreak() for '#pragma rs reduce(redPtrOutBreak)' (reduce_general_bad_result.rs:299:12) parameter 'out' (type 'char **') must not point to a pointer
-reduce_general_bad_result.rs:308:28: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
-reduce_general_bad_result.rs:318:31: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
-reduce_general_bad_result.rs:342:28: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
-reduce_general_bad_result.rs:354:31: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
-reduce_general_bad_result.rs:381:33: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
-reduce_general_bad_result.rs:394:36: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
-reduce_general_bad_result.rs:405:23: error: function types cannot be exported: 'out'
-reduce_general_bad_result.rs:416:52: error: outconverter OutStructIncomplete() for '#pragma rs reduce(redStructIncomplete)' (reduce_general_bad_result.rs:415:12) parameter 'out' (type 'struct Incomplete *') must not point to an incomplete type
-reduce_general_bad_result.rs:427:38: error: outconverter OutArrayIncomplete() for '#pragma rs reduce(redArrayIncomplete)' (reduce_general_bad_result.rs:426:12) parameter 'out' (type 'int (*)[]') must not point to an incomplete type
+reduce_general_bad_result.rs:22:36: error: multidimensional arrays cannot be exported: 'accum'
+reduce_general_bad_result.rs:32:39: error: multidimensional arrays cannot be exported: 'out'
+reduce_general_bad_result.rs:36:7: error: unions cannot be exported: 'UnionShortDouble'
+reduce_general_bad_result.rs:46:7: error: unions cannot be exported: 'UnionLongFloat'
+reduce_general_bad_result.rs:72:7: error: unions cannot be exported: 'UnionIntFloat'
+reduce_general_bad_result.rs:84:7: error: unions cannot be exported: 'UnionCharLong'
+reduce_general_bad_result.rs:113:7: error: bit fields are not able to be exported: 'Bits1.b'
+reduce_general_bad_result.rs:122:7: error: bit fields are not able to be exported: 'Bits111.e'
+reduce_general_bad_result.rs:146:7: error: bit fields are not able to be exported: 'Bits2.b'
+reduce_general_bad_result.rs:157:7: error: bit fields are not able to be exported: 'Bits222.e'
+reduce_general_bad_result.rs:183:36: error: accumulator AccumMat() for '#pragma rs reduce(redMat)' (reduce_general_bad_result.rs:182:12) parameter 'accum' (type 'rs_matrix2x2 *') must not point to a matrix type unless outconverter is provided
+reduce_general_bad_result.rs:191:39: error: outconverter OutMatBreak() for '#pragma rs reduce(redMatOutBreak)' (reduce_general_bad_result.rs:190:12) parameter 'out' (type 'rs_matrix2x2 *') must not point to a matrix type
+reduce_general_bad_result.rs:199:43: error: accumulator AccumMatArray() for '#pragma rs reduce(redMatArray)' (reduce_general_bad_result.rs:198:12) parameter 'accum' (type 'rs_matrix2x2 (*)[10]') must not point to an array of matrix type unless outconverter is provided
+reduce_general_bad_result.rs:209:46: error: outconverter OutMatArrayBreak() for '#pragma rs reduce(redMatArrayOutBreak)' (reduce_general_bad_result.rs:208:12) parameter 'out' (type 'rs_matrix2x2 (*)[10]') must not point to an array of matrix type
+reduce_general_bad_result.rs:215:37: error: outconverter OutAlloc() for '#pragma rs reduce(redAlloc)' (reduce_general_bad_result.rs:214:12) parameter 'out' (type 'struct rs_allocation *') must not point to data containing an object type
+reduce_general_bad_result.rs:224:39: error: outconverter OutAllocArray() for '#pragma rs reduce(redAllocArray)' (reduce_general_bad_result.rs:222:12) parameter 'out' (type 'struct rs_allocation (*)[10]') must not point to data containing an object type
+reduce_general_bad_result.rs:236:45: error: outconverter OutStructObj() for '#pragma rs reduce(redStructObj)' (reduce_general_bad_result.rs:234:12) parameter 'out' (type 'struct StructObj1 *') must not point to data containing an object type
+reduce_general_bad_result.rs:250:48: error: outconverter OutStructObjArray() for '#pragma rs reduce(redStructObjArray)' (reduce_general_bad_result.rs:247:12) parameter 'out' (type 'struct StructObj2 (*)[10]') must not point to data containing an object type
+reduce_general_bad_result.rs:258:27: error: accumulator AccumPtr() for '#pragma rs reduce(redPtr)' (reduce_general_bad_result.rs:257:12) parameter 'accum' (type 'char **') must not point to a pointer unless outconverter is provided
+reduce_general_bad_result.rs:268:30: error: outconverter OutPtrBreak() for '#pragma rs reduce(redPtrOutBreak)' (reduce_general_bad_result.rs:267:12) parameter 'out' (type 'char **') must not point to a pointer
+reduce_general_bad_result.rs:276:28: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
+reduce_general_bad_result.rs:286:31: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
+reduce_general_bad_result.rs:310:28: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
+reduce_general_bad_result.rs:322:31: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
+reduce_general_bad_result.rs:349:33: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'accum'
+reduce_general_bad_result.rs:362:36: error: structures containing pointers cannot be used as the type of an exported global variable or the parameter to an exported function: 'out'
+reduce_general_bad_result.rs:373:23: error: function types cannot be exported: 'out'
+reduce_general_bad_result.rs:384:52: error: outconverter OutStructIncomplete() for '#pragma rs reduce(redStructIncomplete)' (reduce_general_bad_result.rs:383:12) parameter 'out' (type 'struct Incomplete *') must not point to an incomplete type
+reduce_general_bad_result.rs:395:38: error: outconverter OutArrayIncomplete() for '#pragma rs reduce(redArrayIncomplete)' (reduce_general_bad_result.rs:394:12) parameter 'out' (type 'int (*)[]') must not point to an incomplete type
diff --git a/tests/P_reduce_general_accumulator/ScriptC_reduce_general_accumulator.java.expect b/tests/P_reduce_general_accumulator/ScriptC_reduce_general_accumulator.java.expect
new file mode 100644
index 0000000..25c8c05
--- /dev/null
+++ b/tests/P_reduce_general_accumulator/ScriptC_reduce_general_accumulator.java.expect
@@ -0,0 +1,3161 @@
+/*
+ * Copyright (C) 2011-2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This file is auto-generated. DO NOT MODIFY!
+ * The source Renderscript file: reduce_general_accumulator.rs
+ */
+
+package accumulator;
+
+import android.renderscript.*;
+import accumulator.reduce_general_accumulatorBitCode;
+
+/**
+ * @hide
+ */
+public class ScriptC_reduce_general_accumulator extends ScriptC {
+    private static final String __rs_resource_name = "reduce_general_accumulator";
+    // Constructor
+    public  ScriptC_reduce_general_accumulator(RenderScript rs) {
+        super(rs,
+              __rs_resource_name,
+              reduce_general_accumulatorBitCode.getBitCode32(),
+              reduce_general_accumulatorBitCode.getBitCode64());
+        mRSLocal = rs;
+        __I32 = Element.I32(rs);
+    }
+
+    private Element __I32;
+    private RenderScript mRSLocal;
+    // To obtain the result, invoke get(), which blocks
+    // until the asynchronously-launched operation has completed.
+    public static class result_int {
+        public int get() {
+            int[] outArray = new int[1];
+            mOut.copyTo(outArray);
+            return outArray[0];
+        }
+
+        private  result_int(Allocation out) {
+            mOut = out;
+        }
+
+        private Allocation mOut;
+    }
+
+    private final static int mExportReduceNewIdx_my_half = 0;
+    // in1 = "val"
+    public result_int reduce_my_half(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_half(Allocation ain1) {
+        return reduce_my_half(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_half(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_half, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_half2 = 1;
+    // in1 = "val"
+    public result_int reduce_my_half2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_half2(Allocation ain1) {
+        return reduce_my_half2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_half2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_half2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_half4 = 2;
+    // in1 = "val"
+    public result_int reduce_my_half4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_half4(Allocation ain1) {
+        return reduce_my_half4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_half4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_half4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_half = 3;
+    // in1 = "val"
+    public result_int reduce_my_array_half(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_half(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_half(Allocation ain1) {
+        return reduce_my_array_half(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_half(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_half, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_half2 = 4;
+    // in1 = "val"
+    public result_int reduce_my_array_half2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_half2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_half2(Allocation ain1) {
+        return reduce_my_array_half2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_half2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_half2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_half4 = 5;
+    // in1 = "val"
+    public result_int reduce_my_array_half4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_half4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_half4(Allocation ain1) {
+        return reduce_my_array_half4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_half4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_half4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_float = 6;
+    // in1 = "val"
+    public result_int reduce_my_float(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_float(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_float(Allocation ain1) {
+        return reduce_my_float(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_float(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_float, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_float2 = 7;
+    // in1 = "val"
+    public result_int reduce_my_float2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_float2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_float2(Allocation ain1) {
+        return reduce_my_float2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_float2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_float2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_float4 = 8;
+    // in1 = "val"
+    public result_int reduce_my_float4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_float4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_float4(Allocation ain1) {
+        return reduce_my_float4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_float4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_float4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_float = 9;
+    // in1 = "val"
+    public result_int reduce_my_array_float(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_float(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_float(Allocation ain1) {
+        return reduce_my_array_float(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_float(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_float, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_float2 = 10;
+    // in1 = "val"
+    public result_int reduce_my_array_float2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_float2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_float2(Allocation ain1) {
+        return reduce_my_array_float2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_float2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_float2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_float4 = 11;
+    // in1 = "val"
+    public result_int reduce_my_array_float4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_float4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_float4(Allocation ain1) {
+        return reduce_my_array_float4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_float4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_float4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_double = 12;
+    // in1 = "val"
+    public result_int reduce_my_double(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_double(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_double(Allocation ain1) {
+        return reduce_my_double(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_double(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_double, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_double2 = 13;
+    // in1 = "val"
+    public result_int reduce_my_double2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_double2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_double2(Allocation ain1) {
+        return reduce_my_double2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_double2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_double2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_double4 = 14;
+    // in1 = "val"
+    public result_int reduce_my_double4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_double4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_double4(Allocation ain1) {
+        return reduce_my_double4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_double4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_double4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_double = 15;
+    // in1 = "val"
+    public result_int reduce_my_array_double(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_double(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_double(Allocation ain1) {
+        return reduce_my_array_double(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_double(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_double, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_double2 = 16;
+    // in1 = "val"
+    public result_int reduce_my_array_double2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_double2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_double2(Allocation ain1) {
+        return reduce_my_array_double2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_double2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_double2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_double4 = 17;
+    // in1 = "val"
+    public result_int reduce_my_array_double4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_double4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_double4(Allocation ain1) {
+        return reduce_my_array_double4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_double4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_double4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_char = 18;
+    // in1 = "val"
+    public result_int reduce_my_char(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_char(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_char(Allocation ain1) {
+        return reduce_my_char(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_char(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_char, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_char2 = 19;
+    // in1 = "val"
+    public result_int reduce_my_char2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_char2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_char2(Allocation ain1) {
+        return reduce_my_char2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_char2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_char2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_char4 = 20;
+    // in1 = "val"
+    public result_int reduce_my_char4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_char4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_char4(Allocation ain1) {
+        return reduce_my_char4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_char4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_char4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_char = 21;
+    // in1 = "val"
+    public result_int reduce_my_array_char(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_char(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_char(Allocation ain1) {
+        return reduce_my_array_char(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_char(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_char, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_char2 = 22;
+    // in1 = "val"
+    public result_int reduce_my_array_char2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_char2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_char2(Allocation ain1) {
+        return reduce_my_array_char2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_char2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_char2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_char4 = 23;
+    // in1 = "val"
+    public result_int reduce_my_array_char4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_char4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_char4(Allocation ain1) {
+        return reduce_my_array_char4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_char4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_char4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_short = 24;
+    // in1 = "val"
+    public result_int reduce_my_short(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_short(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_short(Allocation ain1) {
+        return reduce_my_short(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_short(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_short, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_short2 = 25;
+    // in1 = "val"
+    public result_int reduce_my_short2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_short2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_short2(Allocation ain1) {
+        return reduce_my_short2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_short2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_short2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_short4 = 26;
+    // in1 = "val"
+    public result_int reduce_my_short4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_short4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_short4(Allocation ain1) {
+        return reduce_my_short4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_short4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_short4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_short = 27;
+    // in1 = "val"
+    public result_int reduce_my_array_short(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_short(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_short(Allocation ain1) {
+        return reduce_my_array_short(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_short(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_short, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_short2 = 28;
+    // in1 = "val"
+    public result_int reduce_my_array_short2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_short2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_short2(Allocation ain1) {
+        return reduce_my_array_short2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_short2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_short2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_short4 = 29;
+    // in1 = "val"
+    public result_int reduce_my_array_short4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_short4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_short4(Allocation ain1) {
+        return reduce_my_array_short4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_short4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_short4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_int = 30;
+    // in1 = "val"
+    public result_int reduce_my_int(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_int(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_int(Allocation ain1) {
+        return reduce_my_int(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_int(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_int, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_int2 = 31;
+    // in1 = "val"
+    public result_int reduce_my_int2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_int2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_int2(Allocation ain1) {
+        return reduce_my_int2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_int2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_int2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_int4 = 32;
+    // in1 = "val"
+    public result_int reduce_my_int4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_int4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_int4(Allocation ain1) {
+        return reduce_my_int4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_int4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_int4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_int = 33;
+    // in1 = "val"
+    public result_int reduce_my_array_int(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_int(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_int(Allocation ain1) {
+        return reduce_my_array_int(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_int(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_int, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_int2 = 34;
+    // in1 = "val"
+    public result_int reduce_my_array_int2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_int2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_int2(Allocation ain1) {
+        return reduce_my_array_int2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_int2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_int2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_int4 = 35;
+    // in1 = "val"
+    public result_int reduce_my_array_int4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_int4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_int4(Allocation ain1) {
+        return reduce_my_array_int4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_int4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_int4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_long = 36;
+    // in1 = "val"
+    public result_int reduce_my_long(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_long(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_long(Allocation ain1) {
+        return reduce_my_long(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_long(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_long, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_long2 = 37;
+    // in1 = "val"
+    public result_int reduce_my_long2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_long2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_long2(Allocation ain1) {
+        return reduce_my_long2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_long2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_long2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_long4 = 38;
+    // in1 = "val"
+    public result_int reduce_my_long4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_long4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_long4(Allocation ain1) {
+        return reduce_my_long4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_long4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_long4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_long = 39;
+    // in1 = "val"
+    public result_int reduce_my_array_long(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_long(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_long(Allocation ain1) {
+        return reduce_my_array_long(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_long(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_long, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_long2 = 40;
+    // in1 = "val"
+    public result_int reduce_my_array_long2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_long2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_long2(Allocation ain1) {
+        return reduce_my_array_long2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_long2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_long2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_long4 = 41;
+    // in1 = "val"
+    public result_int reduce_my_array_long4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_long4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_long4(Allocation ain1) {
+        return reduce_my_array_long4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_long4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_long4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_uchar = 42;
+    // in1 = "val"
+    public result_int reduce_my_uchar(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_uchar(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uchar(Allocation ain1) {
+        return reduce_my_uchar(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uchar(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_uchar, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_uchar2 = 43;
+    // in1 = "val"
+    public result_int reduce_my_uchar2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_uchar2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uchar2(Allocation ain1) {
+        return reduce_my_uchar2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uchar2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_uchar2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_uchar4 = 44;
+    // in1 = "val"
+    public result_int reduce_my_uchar4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_uchar4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uchar4(Allocation ain1) {
+        return reduce_my_uchar4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uchar4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_uchar4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_uchar = 45;
+    // in1 = "val"
+    public result_int reduce_my_array_uchar(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_uchar(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uchar(Allocation ain1) {
+        return reduce_my_array_uchar(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uchar(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_uchar, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_uchar2 = 46;
+    // in1 = "val"
+    public result_int reduce_my_array_uchar2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_uchar2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uchar2(Allocation ain1) {
+        return reduce_my_array_uchar2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uchar2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_uchar2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_uchar4 = 47;
+    // in1 = "val"
+    public result_int reduce_my_array_uchar4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_uchar4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uchar4(Allocation ain1) {
+        return reduce_my_array_uchar4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uchar4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_uchar4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_ushort = 48;
+    // in1 = "val"
+    public result_int reduce_my_ushort(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_ushort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ushort(Allocation ain1) {
+        return reduce_my_ushort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ushort(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_ushort, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_ushort2 = 49;
+    // in1 = "val"
+    public result_int reduce_my_ushort2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_ushort2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ushort2(Allocation ain1) {
+        return reduce_my_ushort2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ushort2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_ushort2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_ushort4 = 50;
+    // in1 = "val"
+    public result_int reduce_my_ushort4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_ushort4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ushort4(Allocation ain1) {
+        return reduce_my_ushort4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ushort4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_ushort4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_ushort = 51;
+    // in1 = "val"
+    public result_int reduce_my_array_ushort(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_ushort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ushort(Allocation ain1) {
+        return reduce_my_array_ushort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ushort(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_ushort, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_ushort2 = 52;
+    // in1 = "val"
+    public result_int reduce_my_array_ushort2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_ushort2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ushort2(Allocation ain1) {
+        return reduce_my_array_ushort2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ushort2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_ushort2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_ushort4 = 53;
+    // in1 = "val"
+    public result_int reduce_my_array_ushort4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_ushort4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ushort4(Allocation ain1) {
+        return reduce_my_array_ushort4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ushort4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_ushort4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_uint = 54;
+    // in1 = "val"
+    public result_int reduce_my_uint(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_uint(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uint(Allocation ain1) {
+        return reduce_my_uint(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uint(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_uint, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_uint2 = 55;
+    // in1 = "val"
+    public result_int reduce_my_uint2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_uint2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uint2(Allocation ain1) {
+        return reduce_my_uint2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uint2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_uint2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_uint4 = 56;
+    // in1 = "val"
+    public result_int reduce_my_uint4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_uint4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uint4(Allocation ain1) {
+        return reduce_my_uint4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_uint4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_uint4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_uint = 57;
+    // in1 = "val"
+    public result_int reduce_my_array_uint(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_uint(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uint(Allocation ain1) {
+        return reduce_my_array_uint(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uint(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_uint, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_uint2 = 58;
+    // in1 = "val"
+    public result_int reduce_my_array_uint2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_uint2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uint2(Allocation ain1) {
+        return reduce_my_array_uint2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uint2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_uint2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_uint4 = 59;
+    // in1 = "val"
+    public result_int reduce_my_array_uint4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_uint4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uint4(Allocation ain1) {
+        return reduce_my_array_uint4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_uint4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_uint4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_ulong = 60;
+    // in1 = "val"
+    public result_int reduce_my_ulong(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_ulong(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ulong(Allocation ain1) {
+        return reduce_my_ulong(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ulong(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_ulong, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_ulong2 = 61;
+    // in1 = "val"
+    public result_int reduce_my_ulong2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_ulong2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ulong2(Allocation ain1) {
+        return reduce_my_ulong2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ulong2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_ulong2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_ulong4 = 62;
+    // in1 = "val"
+    public result_int reduce_my_ulong4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_ulong4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ulong4(Allocation ain1) {
+        return reduce_my_ulong4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_ulong4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_ulong4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_ulong = 63;
+    // in1 = "val"
+    public result_int reduce_my_array_ulong(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_ulong(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ulong(Allocation ain1) {
+        return reduce_my_array_ulong(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ulong(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_ulong, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_ulong2 = 64;
+    // in1 = "val"
+    public result_int reduce_my_array_ulong2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_ulong2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ulong2(Allocation ain1) {
+        return reduce_my_array_ulong2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ulong2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_ulong2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_ulong4 = 65;
+    // in1 = "val"
+    public result_int reduce_my_array_ulong4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_ulong4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ulong4(Allocation ain1) {
+        return reduce_my_array_ulong4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_ulong4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_ulong4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_bool = 66;
+    // in1 = "val"
+    public result_int reduce_my_bool(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_bool(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_bool(Allocation ain1) {
+        return reduce_my_bool(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_bool(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_bool, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_bool = 67;
+    // in1 = "val"
+    public result_int reduce_my_array_bool(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_bool(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_bool(Allocation ain1) {
+        return reduce_my_array_bool(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_bool(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_bool, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_rs_matrix2x2 = 68;
+    // in1 = "val"
+    public result_int reduce_my_rs_matrix2x2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_rs_matrix2x2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_matrix2x2(Allocation ain1) {
+        return reduce_my_rs_matrix2x2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_matrix2x2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_rs_matrix2x2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_rs_matrix2x2 = 69;
+    // in1 = "val"
+    public result_int reduce_my_array_rs_matrix2x2(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_rs_matrix2x2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_matrix2x2(Allocation ain1) {
+        return reduce_my_array_rs_matrix2x2(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_matrix2x2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_rs_matrix2x2, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_rs_matrix3x3 = 70;
+    // in1 = "val"
+    public result_int reduce_my_rs_matrix3x3(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_rs_matrix3x3(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_matrix3x3(Allocation ain1) {
+        return reduce_my_rs_matrix3x3(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_matrix3x3(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_rs_matrix3x3, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_rs_matrix3x3 = 71;
+    // in1 = "val"
+    public result_int reduce_my_array_rs_matrix3x3(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_rs_matrix3x3(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_matrix3x3(Allocation ain1) {
+        return reduce_my_array_rs_matrix3x3(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_matrix3x3(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_rs_matrix3x3, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_rs_matrix4x4 = 72;
+    // in1 = "val"
+    public result_int reduce_my_rs_matrix4x4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_rs_matrix4x4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_matrix4x4(Allocation ain1) {
+        return reduce_my_rs_matrix4x4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_matrix4x4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_rs_matrix4x4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_rs_matrix4x4 = 73;
+    // in1 = "val"
+    public result_int reduce_my_array_rs_matrix4x4(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_rs_matrix4x4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_matrix4x4(Allocation ain1) {
+        return reduce_my_array_rs_matrix4x4(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_matrix4x4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_rs_matrix4x4, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_rs_for_each_strategy_t = 74;
+    // in1 = "val"
+    public result_int reduce_my_rs_for_each_strategy_t(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_rs_for_each_strategy_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_for_each_strategy_t(Allocation ain1) {
+        return reduce_my_rs_for_each_strategy_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_for_each_strategy_t(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_rs_for_each_strategy_t, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_rs_for_each_strategy_t = 75;
+    // in1 = "val"
+    public result_int reduce_my_array_rs_for_each_strategy_t(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_rs_for_each_strategy_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_for_each_strategy_t(Allocation ain1) {
+        return reduce_my_array_rs_for_each_strategy_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_for_each_strategy_t(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_rs_for_each_strategy_t, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_rs_script_call_t = 76;
+    // in1 = "val"
+    public result_int reduce_my_rs_script_call_t(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_rs_script_call_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_script_call_t(Allocation ain1) {
+        return reduce_my_rs_script_call_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_script_call_t(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_rs_script_call_t, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_rs_script_call_t = 77;
+    // in1 = "val"
+    public result_int reduce_my_array_rs_script_call_t(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_rs_script_call_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_script_call_t(Allocation ain1) {
+        return reduce_my_array_rs_script_call_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_script_call_t(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_rs_script_call_t, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_rs_time_t = 78;
+    // in1 = "val"
+    public result_int reduce_my_rs_time_t(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_rs_time_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_time_t(Allocation ain1) {
+        return reduce_my_rs_time_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_time_t(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_rs_time_t, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_rs_time_t = 79;
+    // in1 = "val"
+    public result_int reduce_my_array_rs_time_t(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_rs_time_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_time_t(Allocation ain1) {
+        return reduce_my_array_rs_time_t(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_time_t(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_rs_time_t, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_rs_tm = 80;
+    // in1 = "val"
+    public result_int reduce_my_rs_tm(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_rs_tm(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_tm(Allocation ain1) {
+        return reduce_my_rs_tm(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_rs_tm(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_rs_tm, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_rs_tm = 81;
+    // in1 = "val"
+    public result_int reduce_my_array_rs_tm(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_rs_tm(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_tm(Allocation ain1) {
+        return reduce_my_array_rs_tm(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_rs_tm(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_rs_tm, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyEnum = 82;
+    // in1 = "val"
+    public result_int reduce_my_MyEnum(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyEnum(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyEnum(Allocation ain1) {
+        return reduce_my_MyEnum(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyEnum(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyEnum, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyEnum = 83;
+    // in1 = "val"
+    public result_int reduce_my_array_MyEnum(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyEnum(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyEnum(Allocation ain1) {
+        return reduce_my_array_MyEnum(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyEnum(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyEnum, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyPtrArray = 84;
+    // in1 = "val"
+    public result_int reduce_my_MyPtrArray(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyPtrArray(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrArray(Allocation ain1) {
+        return reduce_my_MyPtrArray(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrArray(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyPtrArray, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyPtrArray = 85;
+    // in1 = "val"
+    public result_int reduce_my_array_MyPtrArray(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyPtrArray(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrArray(Allocation ain1) {
+        return reduce_my_array_MyPtrArray(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrArray(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyPtrArray, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyPtrFn = 86;
+    // in1 = "val"
+    public result_int reduce_my_MyPtrFn(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyPtrFn(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrFn(Allocation ain1) {
+        return reduce_my_MyPtrFn(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrFn(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyPtrFn, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyPtrFn = 87;
+    // in1 = "val"
+    public result_int reduce_my_array_MyPtrFn(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyPtrFn(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrFn(Allocation ain1) {
+        return reduce_my_array_MyPtrFn(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrFn(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyPtrFn, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyPtrIncomplete = 88;
+    // in1 = "val"
+    public result_int reduce_my_MyPtrIncomplete(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyPtrIncomplete(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrIncomplete(Allocation ain1) {
+        return reduce_my_MyPtrIncomplete(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrIncomplete(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyPtrIncomplete, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyPtrIncomplete = 89;
+    // in1 = "val"
+    public result_int reduce_my_array_MyPtrIncomplete(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyPtrIncomplete(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrIncomplete(Allocation ain1) {
+        return reduce_my_array_MyPtrIncomplete(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrIncomplete(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyPtrIncomplete, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyPtrShort = 90;
+    // in1 = "val"
+    public result_int reduce_my_MyPtrShort(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyPtrShort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrShort(Allocation ain1) {
+        return reduce_my_MyPtrShort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrShort(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyPtrShort, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyPtrShort = 91;
+    // in1 = "val"
+    public result_int reduce_my_array_MyPtrShort(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyPtrShort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrShort(Allocation ain1) {
+        return reduce_my_array_MyPtrShort(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrShort(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyPtrShort, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyPtrVoid = 92;
+    // in1 = "val"
+    public result_int reduce_my_MyPtrVoid(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyPtrVoid(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrVoid(Allocation ain1) {
+        return reduce_my_MyPtrVoid(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyPtrVoid(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyPtrVoid, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyPtrVoid = 93;
+    // in1 = "val"
+    public result_int reduce_my_array_MyPtrVoid(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyPtrVoid(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrVoid(Allocation ain1) {
+        return reduce_my_array_MyPtrVoid(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyPtrVoid(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyPtrVoid, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyStruct = 94;
+    // in1 = "val"
+    public result_int reduce_my_MyStruct(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyStruct(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyStruct(Allocation ain1) {
+        return reduce_my_MyStruct(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyStruct(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyStruct, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyStruct = 95;
+    // in1 = "val"
+    public result_int reduce_my_array_MyStruct(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyStruct(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyStruct(Allocation ain1) {
+        return reduce_my_array_MyStruct(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyStruct(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyStruct, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyUnion = 96;
+    // in1 = "val"
+    public result_int reduce_my_MyUnion(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyUnion(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyUnion(Allocation ain1) {
+        return reduce_my_MyUnion(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyUnion(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyUnion, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyUnion = 97;
+    // in1 = "val"
+    public result_int reduce_my_array_MyUnion(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyUnion(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyUnion(Allocation ain1) {
+        return reduce_my_array_MyUnion(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyUnion(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyUnion, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_MyBlob = 98;
+    // in1 = "val"
+    public result_int reduce_my_MyBlob(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_MyBlob(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyBlob(Allocation ain1) {
+        return reduce_my_MyBlob(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_MyBlob(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_MyBlob, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_MyBlob = 99;
+    // in1 = "val"
+    public result_int reduce_my_array_MyBlob(int[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_MyBlob(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyBlob(Allocation ain1) {
+        return reduce_my_array_MyBlob(ain1, null);
+    }
+
+    // ain1 = "int val"
+    public result_int reduce_my_array_MyBlob(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__I32)) {
+            throw new RSRuntimeException("Type mismatch with I32!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_MyBlob, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+}
+
diff --git a/tests/P_reduce_general_accumulator/gen-accumulator.pl b/tests/P_reduce_general_accumulator/gen-accumulator.pl
new file mode 100755
index 0000000..46329e8
--- /dev/null
+++ b/tests/P_reduce_general_accumulator/gen-accumulator.pl
@@ -0,0 +1,66 @@
+#!/usr/bin/perl -w
+
+# Generate trivial test cases to exercise accumulator types.
+
+use strict;
+
+my @basicTypesVectorable = ("half", "float", "double",
+                            "char", "short", "int", "long",
+                            "uchar", "ushort", "uint", "ulong");
+my @basicTypesUnvectorable = ("bool",
+                              "rs_matrix2x2", "rs_matrix3x3", "rs_matrix4x4",
+                              "rs_for_each_strategy_t", "rs_script_call_t", "rs_time_t", "rs_tm",
+                              "MyEnum",
+                              "MyPtrArray", "MyPtrFn", "MyPtrIncomplete", "MyPtrShort", "MyPtrVoid",
+                              "MyStruct", "MyUnion",
+                              "MyBlob");
+my @basicTypes = (@basicTypesVectorable, @basicTypesUnvectorable);
+
+# 1 signifies non-vector
+# 3 is not supported for exported types
+my @vecLengths = (1, 2, 4);
+
+print "// -target-api 0 -Wall -Werror\n";
+print "#pragma version(1)\n";
+print "#pragma rs java_package_name(accumulator)\n\n";
+print "// This test case was created by $0.\n";
+print "// It exercises various legal accumulator types, so that we can ensure\n";
+print "// (a) We do not choke when compiling them\n";
+print "// (b) They do not inhibit reflection\n";
+print "\n// One example enum type\n";
+print "typedef enum { E1, E2, E3 } MyEnum;\n";
+print "\n// Example pointer types\n";
+print "typedef float (*MyPtrArray)[3][11];\n";
+print "typedef int (*MyPtrFn)(double);\n";
+print "typedef struct Incomplete *MyPtrIncomplete;\n";
+print "typedef volatile short *MyPtrShort;\n";
+print "typedef const void *MyPtrVoid;\n";
+print "\n// One example struct type\n";
+print "typedef struct { float f; double d; char *c; } MyStruct;\n";
+print "\n// One example union type\n";
+print "typedef union { int i; long l; int a[5]; } MyUnion;\n";
+print "\n// One example of a more-complicated type\n";
+print "typedef struct { MyEnum e1, e2; MyPtrIncomplete p; MyStruct s; MyUnion u; } MyBlob;\n";
+
+foreach my $basicType (@basicTypes) {
+  for (my $isArray = 0; $isArray <= 1; ++$isArray) {
+    foreach my $vecLen (@vecLengths) {
+
+      next if ($vecLen > 1) && !grep(/^${basicType}$/, @basicTypesVectorable);
+
+      my $eltName = $basicType;
+      $eltName .= $vecLen if ($vecLen > 1);
+      my $resultName = ($isArray ? "array_${eltName}" : $eltName);
+      my $reduceName = "my_${resultName}";
+      my $accumName = "${reduceName}_accum";
+      my $combName = "${reduceName}_comb";
+      my $outName = "${reduceName}_out";
+      print "\n";
+      print "#pragma rs reduce(${reduceName}) accumulator(${accumName}) combiner(${combName}) outconverter(${outName})\n";
+      print "typedef ${eltName} ${resultName}[7];\n" if ($isArray);
+      print "static void ${accumName}(${resultName} *accum, int val) { }\n";
+      print "static void ${combName}(${resultName} *accum, const ${resultName} *other) { }\n";
+      print "static void ${outName}(int *out, const ${resultName} *accum) { }\n";
+    }
+  }
+}
diff --git a/tests/P_reduce_general_accumulator/reduce_general_accumulator.rs b/tests/P_reduce_general_accumulator/reduce_general_accumulator.rs
new file mode 100644
index 0000000..cec196d
--- /dev/null
+++ b/tests/P_reduce_general_accumulator/reduce_general_accumulator.rs
@@ -0,0 +1,577 @@
+// -target-api 0 -Wall -Werror
+#pragma version(1)
+#pragma rs java_package_name(accumulator)
+
+// This test case was created by ./gen-accumulator.pl.
+// It exercises various legal accumulator types, so that we can ensure
+// (a) We do not choke when compiling them
+// (b) They do not inhibit reflection
+
+// One example enum type
+typedef enum { E1, E2, E3 } MyEnum;
+
+// Example pointer types
+typedef float (*MyPtrArray)[3][11];
+typedef int (*MyPtrFn)(double);
+typedef struct Incomplete *MyPtrIncomplete;
+typedef volatile short *MyPtrShort;
+typedef const void *MyPtrVoid;
+
+// One example struct type
+typedef struct { float f; double d; char *c; } MyStruct;
+
+// One example union type
+typedef union { int i; long l; int a[5]; } MyUnion;
+
+// One example of a more-complicated type
+typedef struct { MyEnum e1, e2; MyPtrIncomplete p; MyStruct s; MyUnion u; } MyBlob;
+
+#pragma rs reduce(my_half) accumulator(my_half_accum) combiner(my_half_comb) outconverter(my_half_out)
+static void my_half_accum(half *accum, int val) { }
+static void my_half_comb(half *accum, const half *other) { }
+static void my_half_out(int *out, const half *accum) { }
+
+#pragma rs reduce(my_half2) accumulator(my_half2_accum) combiner(my_half2_comb) outconverter(my_half2_out)
+static void my_half2_accum(half2 *accum, int val) { }
+static void my_half2_comb(half2 *accum, const half2 *other) { }
+static void my_half2_out(int *out, const half2 *accum) { }
+
+#pragma rs reduce(my_half4) accumulator(my_half4_accum) combiner(my_half4_comb) outconverter(my_half4_out)
+static void my_half4_accum(half4 *accum, int val) { }
+static void my_half4_comb(half4 *accum, const half4 *other) { }
+static void my_half4_out(int *out, const half4 *accum) { }
+
+#pragma rs reduce(my_array_half) accumulator(my_array_half_accum) combiner(my_array_half_comb) outconverter(my_array_half_out)
+typedef half array_half[7];
+static void my_array_half_accum(array_half *accum, int val) { }
+static void my_array_half_comb(array_half *accum, const array_half *other) { }
+static void my_array_half_out(int *out, const array_half *accum) { }
+
+#pragma rs reduce(my_array_half2) accumulator(my_array_half2_accum) combiner(my_array_half2_comb) outconverter(my_array_half2_out)
+typedef half2 array_half2[7];
+static void my_array_half2_accum(array_half2 *accum, int val) { }
+static void my_array_half2_comb(array_half2 *accum, const array_half2 *other) { }
+static void my_array_half2_out(int *out, const array_half2 *accum) { }
+
+#pragma rs reduce(my_array_half4) accumulator(my_array_half4_accum) combiner(my_array_half4_comb) outconverter(my_array_half4_out)
+typedef half4 array_half4[7];
+static void my_array_half4_accum(array_half4 *accum, int val) { }
+static void my_array_half4_comb(array_half4 *accum, const array_half4 *other) { }
+static void my_array_half4_out(int *out, const array_half4 *accum) { }
+
+#pragma rs reduce(my_float) accumulator(my_float_accum) combiner(my_float_comb) outconverter(my_float_out)
+static void my_float_accum(float *accum, int val) { }
+static void my_float_comb(float *accum, const float *other) { }
+static void my_float_out(int *out, const float *accum) { }
+
+#pragma rs reduce(my_float2) accumulator(my_float2_accum) combiner(my_float2_comb) outconverter(my_float2_out)
+static void my_float2_accum(float2 *accum, int val) { }
+static void my_float2_comb(float2 *accum, const float2 *other) { }
+static void my_float2_out(int *out, const float2 *accum) { }
+
+#pragma rs reduce(my_float4) accumulator(my_float4_accum) combiner(my_float4_comb) outconverter(my_float4_out)
+static void my_float4_accum(float4 *accum, int val) { }
+static void my_float4_comb(float4 *accum, const float4 *other) { }
+static void my_float4_out(int *out, const float4 *accum) { }
+
+#pragma rs reduce(my_array_float) accumulator(my_array_float_accum) combiner(my_array_float_comb) outconverter(my_array_float_out)
+typedef float array_float[7];
+static void my_array_float_accum(array_float *accum, int val) { }
+static void my_array_float_comb(array_float *accum, const array_float *other) { }
+static void my_array_float_out(int *out, const array_float *accum) { }
+
+#pragma rs reduce(my_array_float2) accumulator(my_array_float2_accum) combiner(my_array_float2_comb) outconverter(my_array_float2_out)
+typedef float2 array_float2[7];
+static void my_array_float2_accum(array_float2 *accum, int val) { }
+static void my_array_float2_comb(array_float2 *accum, const array_float2 *other) { }
+static void my_array_float2_out(int *out, const array_float2 *accum) { }
+
+#pragma rs reduce(my_array_float4) accumulator(my_array_float4_accum) combiner(my_array_float4_comb) outconverter(my_array_float4_out)
+typedef float4 array_float4[7];
+static void my_array_float4_accum(array_float4 *accum, int val) { }
+static void my_array_float4_comb(array_float4 *accum, const array_float4 *other) { }
+static void my_array_float4_out(int *out, const array_float4 *accum) { }
+
+#pragma rs reduce(my_double) accumulator(my_double_accum) combiner(my_double_comb) outconverter(my_double_out)
+static void my_double_accum(double *accum, int val) { }
+static void my_double_comb(double *accum, const double *other) { }
+static void my_double_out(int *out, const double *accum) { }
+
+#pragma rs reduce(my_double2) accumulator(my_double2_accum) combiner(my_double2_comb) outconverter(my_double2_out)
+static void my_double2_accum(double2 *accum, int val) { }
+static void my_double2_comb(double2 *accum, const double2 *other) { }
+static void my_double2_out(int *out, const double2 *accum) { }
+
+#pragma rs reduce(my_double4) accumulator(my_double4_accum) combiner(my_double4_comb) outconverter(my_double4_out)
+static void my_double4_accum(double4 *accum, int val) { }
+static void my_double4_comb(double4 *accum, const double4 *other) { }
+static void my_double4_out(int *out, const double4 *accum) { }
+
+#pragma rs reduce(my_array_double) accumulator(my_array_double_accum) combiner(my_array_double_comb) outconverter(my_array_double_out)
+typedef double array_double[7];
+static void my_array_double_accum(array_double *accum, int val) { }
+static void my_array_double_comb(array_double *accum, const array_double *other) { }
+static void my_array_double_out(int *out, const array_double *accum) { }
+
+#pragma rs reduce(my_array_double2) accumulator(my_array_double2_accum) combiner(my_array_double2_comb) outconverter(my_array_double2_out)
+typedef double2 array_double2[7];
+static void my_array_double2_accum(array_double2 *accum, int val) { }
+static void my_array_double2_comb(array_double2 *accum, const array_double2 *other) { }
+static void my_array_double2_out(int *out, const array_double2 *accum) { }
+
+#pragma rs reduce(my_array_double4) accumulator(my_array_double4_accum) combiner(my_array_double4_comb) outconverter(my_array_double4_out)
+typedef double4 array_double4[7];
+static void my_array_double4_accum(array_double4 *accum, int val) { }
+static void my_array_double4_comb(array_double4 *accum, const array_double4 *other) { }
+static void my_array_double4_out(int *out, const array_double4 *accum) { }
+
+#pragma rs reduce(my_char) accumulator(my_char_accum) combiner(my_char_comb) outconverter(my_char_out)
+static void my_char_accum(char *accum, int val) { }
+static void my_char_comb(char *accum, const char *other) { }
+static void my_char_out(int *out, const char *accum) { }
+
+#pragma rs reduce(my_char2) accumulator(my_char2_accum) combiner(my_char2_comb) outconverter(my_char2_out)
+static void my_char2_accum(char2 *accum, int val) { }
+static void my_char2_comb(char2 *accum, const char2 *other) { }
+static void my_char2_out(int *out, const char2 *accum) { }
+
+#pragma rs reduce(my_char4) accumulator(my_char4_accum) combiner(my_char4_comb) outconverter(my_char4_out)
+static void my_char4_accum(char4 *accum, int val) { }
+static void my_char4_comb(char4 *accum, const char4 *other) { }
+static void my_char4_out(int *out, const char4 *accum) { }
+
+#pragma rs reduce(my_array_char) accumulator(my_array_char_accum) combiner(my_array_char_comb) outconverter(my_array_char_out)
+typedef char array_char[7];
+static void my_array_char_accum(array_char *accum, int val) { }
+static void my_array_char_comb(array_char *accum, const array_char *other) { }
+static void my_array_char_out(int *out, const array_char *accum) { }
+
+#pragma rs reduce(my_array_char2) accumulator(my_array_char2_accum) combiner(my_array_char2_comb) outconverter(my_array_char2_out)
+typedef char2 array_char2[7];
+static void my_array_char2_accum(array_char2 *accum, int val) { }
+static void my_array_char2_comb(array_char2 *accum, const array_char2 *other) { }
+static void my_array_char2_out(int *out, const array_char2 *accum) { }
+
+#pragma rs reduce(my_array_char4) accumulator(my_array_char4_accum) combiner(my_array_char4_comb) outconverter(my_array_char4_out)
+typedef char4 array_char4[7];
+static void my_array_char4_accum(array_char4 *accum, int val) { }
+static void my_array_char4_comb(array_char4 *accum, const array_char4 *other) { }
+static void my_array_char4_out(int *out, const array_char4 *accum) { }
+
+#pragma rs reduce(my_short) accumulator(my_short_accum) combiner(my_short_comb) outconverter(my_short_out)
+static void my_short_accum(short *accum, int val) { }
+static void my_short_comb(short *accum, const short *other) { }
+static void my_short_out(int *out, const short *accum) { }
+
+#pragma rs reduce(my_short2) accumulator(my_short2_accum) combiner(my_short2_comb) outconverter(my_short2_out)
+static void my_short2_accum(short2 *accum, int val) { }
+static void my_short2_comb(short2 *accum, const short2 *other) { }
+static void my_short2_out(int *out, const short2 *accum) { }
+
+#pragma rs reduce(my_short4) accumulator(my_short4_accum) combiner(my_short4_comb) outconverter(my_short4_out)
+static void my_short4_accum(short4 *accum, int val) { }
+static void my_short4_comb(short4 *accum, const short4 *other) { }
+static void my_short4_out(int *out, const short4 *accum) { }
+
+#pragma rs reduce(my_array_short) accumulator(my_array_short_accum) combiner(my_array_short_comb) outconverter(my_array_short_out)
+typedef short array_short[7];
+static void my_array_short_accum(array_short *accum, int val) { }
+static void my_array_short_comb(array_short *accum, const array_short *other) { }
+static void my_array_short_out(int *out, const array_short *accum) { }
+
+#pragma rs reduce(my_array_short2) accumulator(my_array_short2_accum) combiner(my_array_short2_comb) outconverter(my_array_short2_out)
+typedef short2 array_short2[7];
+static void my_array_short2_accum(array_short2 *accum, int val) { }
+static void my_array_short2_comb(array_short2 *accum, const array_short2 *other) { }
+static void my_array_short2_out(int *out, const array_short2 *accum) { }
+
+#pragma rs reduce(my_array_short4) accumulator(my_array_short4_accum) combiner(my_array_short4_comb) outconverter(my_array_short4_out)
+typedef short4 array_short4[7];
+static void my_array_short4_accum(array_short4 *accum, int val) { }
+static void my_array_short4_comb(array_short4 *accum, const array_short4 *other) { }
+static void my_array_short4_out(int *out, const array_short4 *accum) { }
+
+#pragma rs reduce(my_int) accumulator(my_int_accum) combiner(my_int_comb) outconverter(my_int_out)
+static void my_int_accum(int *accum, int val) { }
+static void my_int_comb(int *accum, const int *other) { }
+static void my_int_out(int *out, const int *accum) { }
+
+#pragma rs reduce(my_int2) accumulator(my_int2_accum) combiner(my_int2_comb) outconverter(my_int2_out)
+static void my_int2_accum(int2 *accum, int val) { }
+static void my_int2_comb(int2 *accum, const int2 *other) { }
+static void my_int2_out(int *out, const int2 *accum) { }
+
+#pragma rs reduce(my_int4) accumulator(my_int4_accum) combiner(my_int4_comb) outconverter(my_int4_out)
+static void my_int4_accum(int4 *accum, int val) { }
+static void my_int4_comb(int4 *accum, const int4 *other) { }
+static void my_int4_out(int *out, const int4 *accum) { }
+
+#pragma rs reduce(my_array_int) accumulator(my_array_int_accum) combiner(my_array_int_comb) outconverter(my_array_int_out)
+typedef int array_int[7];
+static void my_array_int_accum(array_int *accum, int val) { }
+static void my_array_int_comb(array_int *accum, const array_int *other) { }
+static void my_array_int_out(int *out, const array_int *accum) { }
+
+#pragma rs reduce(my_array_int2) accumulator(my_array_int2_accum) combiner(my_array_int2_comb) outconverter(my_array_int2_out)
+typedef int2 array_int2[7];
+static void my_array_int2_accum(array_int2 *accum, int val) { }
+static void my_array_int2_comb(array_int2 *accum, const array_int2 *other) { }
+static void my_array_int2_out(int *out, const array_int2 *accum) { }
+
+#pragma rs reduce(my_array_int4) accumulator(my_array_int4_accum) combiner(my_array_int4_comb) outconverter(my_array_int4_out)
+typedef int4 array_int4[7];
+static void my_array_int4_accum(array_int4 *accum, int val) { }
+static void my_array_int4_comb(array_int4 *accum, const array_int4 *other) { }
+static void my_array_int4_out(int *out, const array_int4 *accum) { }
+
+#pragma rs reduce(my_long) accumulator(my_long_accum) combiner(my_long_comb) outconverter(my_long_out)
+static void my_long_accum(long *accum, int val) { }
+static void my_long_comb(long *accum, const long *other) { }
+static void my_long_out(int *out, const long *accum) { }
+
+#pragma rs reduce(my_long2) accumulator(my_long2_accum) combiner(my_long2_comb) outconverter(my_long2_out)
+static void my_long2_accum(long2 *accum, int val) { }
+static void my_long2_comb(long2 *accum, const long2 *other) { }
+static void my_long2_out(int *out, const long2 *accum) { }
+
+#pragma rs reduce(my_long4) accumulator(my_long4_accum) combiner(my_long4_comb) outconverter(my_long4_out)
+static void my_long4_accum(long4 *accum, int val) { }
+static void my_long4_comb(long4 *accum, const long4 *other) { }
+static void my_long4_out(int *out, const long4 *accum) { }
+
+#pragma rs reduce(my_array_long) accumulator(my_array_long_accum) combiner(my_array_long_comb) outconverter(my_array_long_out)
+typedef long array_long[7];
+static void my_array_long_accum(array_long *accum, int val) { }
+static void my_array_long_comb(array_long *accum, const array_long *other) { }
+static void my_array_long_out(int *out, const array_long *accum) { }
+
+#pragma rs reduce(my_array_long2) accumulator(my_array_long2_accum) combiner(my_array_long2_comb) outconverter(my_array_long2_out)
+typedef long2 array_long2[7];
+static void my_array_long2_accum(array_long2 *accum, int val) { }
+static void my_array_long2_comb(array_long2 *accum, const array_long2 *other) { }
+static void my_array_long2_out(int *out, const array_long2 *accum) { }
+
+#pragma rs reduce(my_array_long4) accumulator(my_array_long4_accum) combiner(my_array_long4_comb) outconverter(my_array_long4_out)
+typedef long4 array_long4[7];
+static void my_array_long4_accum(array_long4 *accum, int val) { }
+static void my_array_long4_comb(array_long4 *accum, const array_long4 *other) { }
+static void my_array_long4_out(int *out, const array_long4 *accum) { }
+
+#pragma rs reduce(my_uchar) accumulator(my_uchar_accum) combiner(my_uchar_comb) outconverter(my_uchar_out)
+static void my_uchar_accum(uchar *accum, int val) { }
+static void my_uchar_comb(uchar *accum, const uchar *other) { }
+static void my_uchar_out(int *out, const uchar *accum) { }
+
+#pragma rs reduce(my_uchar2) accumulator(my_uchar2_accum) combiner(my_uchar2_comb) outconverter(my_uchar2_out)
+static void my_uchar2_accum(uchar2 *accum, int val) { }
+static void my_uchar2_comb(uchar2 *accum, const uchar2 *other) { }
+static void my_uchar2_out(int *out, const uchar2 *accum) { }
+
+#pragma rs reduce(my_uchar4) accumulator(my_uchar4_accum) combiner(my_uchar4_comb) outconverter(my_uchar4_out)
+static void my_uchar4_accum(uchar4 *accum, int val) { }
+static void my_uchar4_comb(uchar4 *accum, const uchar4 *other) { }
+static void my_uchar4_out(int *out, const uchar4 *accum) { }
+
+#pragma rs reduce(my_array_uchar) accumulator(my_array_uchar_accum) combiner(my_array_uchar_comb) outconverter(my_array_uchar_out)
+typedef uchar array_uchar[7];
+static void my_array_uchar_accum(array_uchar *accum, int val) { }
+static void my_array_uchar_comb(array_uchar *accum, const array_uchar *other) { }
+static void my_array_uchar_out(int *out, const array_uchar *accum) { }
+
+#pragma rs reduce(my_array_uchar2) accumulator(my_array_uchar2_accum) combiner(my_array_uchar2_comb) outconverter(my_array_uchar2_out)
+typedef uchar2 array_uchar2[7];
+static void my_array_uchar2_accum(array_uchar2 *accum, int val) { }
+static void my_array_uchar2_comb(array_uchar2 *accum, const array_uchar2 *other) { }
+static void my_array_uchar2_out(int *out, const array_uchar2 *accum) { }
+
+#pragma rs reduce(my_array_uchar4) accumulator(my_array_uchar4_accum) combiner(my_array_uchar4_comb) outconverter(my_array_uchar4_out)
+typedef uchar4 array_uchar4[7];
+static void my_array_uchar4_accum(array_uchar4 *accum, int val) { }
+static void my_array_uchar4_comb(array_uchar4 *accum, const array_uchar4 *other) { }
+static void my_array_uchar4_out(int *out, const array_uchar4 *accum) { }
+
+#pragma rs reduce(my_ushort) accumulator(my_ushort_accum) combiner(my_ushort_comb) outconverter(my_ushort_out)
+static void my_ushort_accum(ushort *accum, int val) { }
+static void my_ushort_comb(ushort *accum, const ushort *other) { }
+static void my_ushort_out(int *out, const ushort *accum) { }
+
+#pragma rs reduce(my_ushort2) accumulator(my_ushort2_accum) combiner(my_ushort2_comb) outconverter(my_ushort2_out)
+static void my_ushort2_accum(ushort2 *accum, int val) { }
+static void my_ushort2_comb(ushort2 *accum, const ushort2 *other) { }
+static void my_ushort2_out(int *out, const ushort2 *accum) { }
+
+#pragma rs reduce(my_ushort4) accumulator(my_ushort4_accum) combiner(my_ushort4_comb) outconverter(my_ushort4_out)
+static void my_ushort4_accum(ushort4 *accum, int val) { }
+static void my_ushort4_comb(ushort4 *accum, const ushort4 *other) { }
+static void my_ushort4_out(int *out, const ushort4 *accum) { }
+
+#pragma rs reduce(my_array_ushort) accumulator(my_array_ushort_accum) combiner(my_array_ushort_comb) outconverter(my_array_ushort_out)
+typedef ushort array_ushort[7];
+static void my_array_ushort_accum(array_ushort *accum, int val) { }
+static void my_array_ushort_comb(array_ushort *accum, const array_ushort *other) { }
+static void my_array_ushort_out(int *out, const array_ushort *accum) { }
+
+#pragma rs reduce(my_array_ushort2) accumulator(my_array_ushort2_accum) combiner(my_array_ushort2_comb) outconverter(my_array_ushort2_out)
+typedef ushort2 array_ushort2[7];
+static void my_array_ushort2_accum(array_ushort2 *accum, int val) { }
+static void my_array_ushort2_comb(array_ushort2 *accum, const array_ushort2 *other) { }
+static void my_array_ushort2_out(int *out, const array_ushort2 *accum) { }
+
+#pragma rs reduce(my_array_ushort4) accumulator(my_array_ushort4_accum) combiner(my_array_ushort4_comb) outconverter(my_array_ushort4_out)
+typedef ushort4 array_ushort4[7];
+static void my_array_ushort4_accum(array_ushort4 *accum, int val) { }
+static void my_array_ushort4_comb(array_ushort4 *accum, const array_ushort4 *other) { }
+static void my_array_ushort4_out(int *out, const array_ushort4 *accum) { }
+
+#pragma rs reduce(my_uint) accumulator(my_uint_accum) combiner(my_uint_comb) outconverter(my_uint_out)
+static void my_uint_accum(uint *accum, int val) { }
+static void my_uint_comb(uint *accum, const uint *other) { }
+static void my_uint_out(int *out, const uint *accum) { }
+
+#pragma rs reduce(my_uint2) accumulator(my_uint2_accum) combiner(my_uint2_comb) outconverter(my_uint2_out)
+static void my_uint2_accum(uint2 *accum, int val) { }
+static void my_uint2_comb(uint2 *accum, const uint2 *other) { }
+static void my_uint2_out(int *out, const uint2 *accum) { }
+
+#pragma rs reduce(my_uint4) accumulator(my_uint4_accum) combiner(my_uint4_comb) outconverter(my_uint4_out)
+static void my_uint4_accum(uint4 *accum, int val) { }
+static void my_uint4_comb(uint4 *accum, const uint4 *other) { }
+static void my_uint4_out(int *out, const uint4 *accum) { }
+
+#pragma rs reduce(my_array_uint) accumulator(my_array_uint_accum) combiner(my_array_uint_comb) outconverter(my_array_uint_out)
+typedef uint array_uint[7];
+static void my_array_uint_accum(array_uint *accum, int val) { }
+static void my_array_uint_comb(array_uint *accum, const array_uint *other) { }
+static void my_array_uint_out(int *out, const array_uint *accum) { }
+
+#pragma rs reduce(my_array_uint2) accumulator(my_array_uint2_accum) combiner(my_array_uint2_comb) outconverter(my_array_uint2_out)
+typedef uint2 array_uint2[7];
+static void my_array_uint2_accum(array_uint2 *accum, int val) { }
+static void my_array_uint2_comb(array_uint2 *accum, const array_uint2 *other) { }
+static void my_array_uint2_out(int *out, const array_uint2 *accum) { }
+
+#pragma rs reduce(my_array_uint4) accumulator(my_array_uint4_accum) combiner(my_array_uint4_comb) outconverter(my_array_uint4_out)
+typedef uint4 array_uint4[7];
+static void my_array_uint4_accum(array_uint4 *accum, int val) { }
+static void my_array_uint4_comb(array_uint4 *accum, const array_uint4 *other) { }
+static void my_array_uint4_out(int *out, const array_uint4 *accum) { }
+
+#pragma rs reduce(my_ulong) accumulator(my_ulong_accum) combiner(my_ulong_comb) outconverter(my_ulong_out)
+static void my_ulong_accum(ulong *accum, int val) { }
+static void my_ulong_comb(ulong *accum, const ulong *other) { }
+static void my_ulong_out(int *out, const ulong *accum) { }
+
+#pragma rs reduce(my_ulong2) accumulator(my_ulong2_accum) combiner(my_ulong2_comb) outconverter(my_ulong2_out)
+static void my_ulong2_accum(ulong2 *accum, int val) { }
+static void my_ulong2_comb(ulong2 *accum, const ulong2 *other) { }
+static void my_ulong2_out(int *out, const ulong2 *accum) { }
+
+#pragma rs reduce(my_ulong4) accumulator(my_ulong4_accum) combiner(my_ulong4_comb) outconverter(my_ulong4_out)
+static void my_ulong4_accum(ulong4 *accum, int val) { }
+static void my_ulong4_comb(ulong4 *accum, const ulong4 *other) { }
+static void my_ulong4_out(int *out, const ulong4 *accum) { }
+
+#pragma rs reduce(my_array_ulong) accumulator(my_array_ulong_accum) combiner(my_array_ulong_comb) outconverter(my_array_ulong_out)
+typedef ulong array_ulong[7];
+static void my_array_ulong_accum(array_ulong *accum, int val) { }
+static void my_array_ulong_comb(array_ulong *accum, const array_ulong *other) { }
+static void my_array_ulong_out(int *out, const array_ulong *accum) { }
+
+#pragma rs reduce(my_array_ulong2) accumulator(my_array_ulong2_accum) combiner(my_array_ulong2_comb) outconverter(my_array_ulong2_out)
+typedef ulong2 array_ulong2[7];
+static void my_array_ulong2_accum(array_ulong2 *accum, int val) { }
+static void my_array_ulong2_comb(array_ulong2 *accum, const array_ulong2 *other) { }
+static void my_array_ulong2_out(int *out, const array_ulong2 *accum) { }
+
+#pragma rs reduce(my_array_ulong4) accumulator(my_array_ulong4_accum) combiner(my_array_ulong4_comb) outconverter(my_array_ulong4_out)
+typedef ulong4 array_ulong4[7];
+static void my_array_ulong4_accum(array_ulong4 *accum, int val) { }
+static void my_array_ulong4_comb(array_ulong4 *accum, const array_ulong4 *other) { }
+static void my_array_ulong4_out(int *out, const array_ulong4 *accum) { }
+
+#pragma rs reduce(my_bool) accumulator(my_bool_accum) combiner(my_bool_comb) outconverter(my_bool_out)
+static void my_bool_accum(bool *accum, int val) { }
+static void my_bool_comb(bool *accum, const bool *other) { }
+static void my_bool_out(int *out, const bool *accum) { }
+
+#pragma rs reduce(my_array_bool) accumulator(my_array_bool_accum) combiner(my_array_bool_comb) outconverter(my_array_bool_out)
+typedef bool array_bool[7];
+static void my_array_bool_accum(array_bool *accum, int val) { }
+static void my_array_bool_comb(array_bool *accum, const array_bool *other) { }
+static void my_array_bool_out(int *out, const array_bool *accum) { }
+
+#pragma rs reduce(my_rs_matrix2x2) accumulator(my_rs_matrix2x2_accum) combiner(my_rs_matrix2x2_comb) outconverter(my_rs_matrix2x2_out)
+static void my_rs_matrix2x2_accum(rs_matrix2x2 *accum, int val) { }
+static void my_rs_matrix2x2_comb(rs_matrix2x2 *accum, const rs_matrix2x2 *other) { }
+static void my_rs_matrix2x2_out(int *out, const rs_matrix2x2 *accum) { }
+
+#pragma rs reduce(my_array_rs_matrix2x2) accumulator(my_array_rs_matrix2x2_accum) combiner(my_array_rs_matrix2x2_comb) outconverter(my_array_rs_matrix2x2_out)
+typedef rs_matrix2x2 array_rs_matrix2x2[7];
+static void my_array_rs_matrix2x2_accum(array_rs_matrix2x2 *accum, int val) { }
+static void my_array_rs_matrix2x2_comb(array_rs_matrix2x2 *accum, const array_rs_matrix2x2 *other) { }
+static void my_array_rs_matrix2x2_out(int *out, const array_rs_matrix2x2 *accum) { }
+
+#pragma rs reduce(my_rs_matrix3x3) accumulator(my_rs_matrix3x3_accum) combiner(my_rs_matrix3x3_comb) outconverter(my_rs_matrix3x3_out)
+static void my_rs_matrix3x3_accum(rs_matrix3x3 *accum, int val) { }
+static void my_rs_matrix3x3_comb(rs_matrix3x3 *accum, const rs_matrix3x3 *other) { }
+static void my_rs_matrix3x3_out(int *out, const rs_matrix3x3 *accum) { }
+
+#pragma rs reduce(my_array_rs_matrix3x3) accumulator(my_array_rs_matrix3x3_accum) combiner(my_array_rs_matrix3x3_comb) outconverter(my_array_rs_matrix3x3_out)
+typedef rs_matrix3x3 array_rs_matrix3x3[7];
+static void my_array_rs_matrix3x3_accum(array_rs_matrix3x3 *accum, int val) { }
+static void my_array_rs_matrix3x3_comb(array_rs_matrix3x3 *accum, const array_rs_matrix3x3 *other) { }
+static void my_array_rs_matrix3x3_out(int *out, const array_rs_matrix3x3 *accum) { }
+
+#pragma rs reduce(my_rs_matrix4x4) accumulator(my_rs_matrix4x4_accum) combiner(my_rs_matrix4x4_comb) outconverter(my_rs_matrix4x4_out)
+static void my_rs_matrix4x4_accum(rs_matrix4x4 *accum, int val) { }
+static void my_rs_matrix4x4_comb(rs_matrix4x4 *accum, const rs_matrix4x4 *other) { }
+static void my_rs_matrix4x4_out(int *out, const rs_matrix4x4 *accum) { }
+
+#pragma rs reduce(my_array_rs_matrix4x4) accumulator(my_array_rs_matrix4x4_accum) combiner(my_array_rs_matrix4x4_comb) outconverter(my_array_rs_matrix4x4_out)
+typedef rs_matrix4x4 array_rs_matrix4x4[7];
+static void my_array_rs_matrix4x4_accum(array_rs_matrix4x4 *accum, int val) { }
+static void my_array_rs_matrix4x4_comb(array_rs_matrix4x4 *accum, const array_rs_matrix4x4 *other) { }
+static void my_array_rs_matrix4x4_out(int *out, const array_rs_matrix4x4 *accum) { }
+
+#pragma rs reduce(my_rs_for_each_strategy_t) accumulator(my_rs_for_each_strategy_t_accum) combiner(my_rs_for_each_strategy_t_comb) outconverter(my_rs_for_each_strategy_t_out)
+static void my_rs_for_each_strategy_t_accum(rs_for_each_strategy_t *accum, int val) { }
+static void my_rs_for_each_strategy_t_comb(rs_for_each_strategy_t *accum, const rs_for_each_strategy_t *other) { }
+static void my_rs_for_each_strategy_t_out(int *out, const rs_for_each_strategy_t *accum) { }
+
+#pragma rs reduce(my_array_rs_for_each_strategy_t) accumulator(my_array_rs_for_each_strategy_t_accum) combiner(my_array_rs_for_each_strategy_t_comb) outconverter(my_array_rs_for_each_strategy_t_out)
+typedef rs_for_each_strategy_t array_rs_for_each_strategy_t[7];
+static void my_array_rs_for_each_strategy_t_accum(array_rs_for_each_strategy_t *accum, int val) { }
+static void my_array_rs_for_each_strategy_t_comb(array_rs_for_each_strategy_t *accum, const array_rs_for_each_strategy_t *other) { }
+static void my_array_rs_for_each_strategy_t_out(int *out, const array_rs_for_each_strategy_t *accum) { }
+
+#pragma rs reduce(my_rs_script_call_t) accumulator(my_rs_script_call_t_accum) combiner(my_rs_script_call_t_comb) outconverter(my_rs_script_call_t_out)
+static void my_rs_script_call_t_accum(rs_script_call_t *accum, int val) { }
+static void my_rs_script_call_t_comb(rs_script_call_t *accum, const rs_script_call_t *other) { }
+static void my_rs_script_call_t_out(int *out, const rs_script_call_t *accum) { }
+
+#pragma rs reduce(my_array_rs_script_call_t) accumulator(my_array_rs_script_call_t_accum) combiner(my_array_rs_script_call_t_comb) outconverter(my_array_rs_script_call_t_out)
+typedef rs_script_call_t array_rs_script_call_t[7];
+static void my_array_rs_script_call_t_accum(array_rs_script_call_t *accum, int val) { }
+static void my_array_rs_script_call_t_comb(array_rs_script_call_t *accum, const array_rs_script_call_t *other) { }
+static void my_array_rs_script_call_t_out(int *out, const array_rs_script_call_t *accum) { }
+
+#pragma rs reduce(my_rs_time_t) accumulator(my_rs_time_t_accum) combiner(my_rs_time_t_comb) outconverter(my_rs_time_t_out)
+static void my_rs_time_t_accum(rs_time_t *accum, int val) { }
+static void my_rs_time_t_comb(rs_time_t *accum, const rs_time_t *other) { }
+static void my_rs_time_t_out(int *out, const rs_time_t *accum) { }
+
+#pragma rs reduce(my_array_rs_time_t) accumulator(my_array_rs_time_t_accum) combiner(my_array_rs_time_t_comb) outconverter(my_array_rs_time_t_out)
+typedef rs_time_t array_rs_time_t[7];
+static void my_array_rs_time_t_accum(array_rs_time_t *accum, int val) { }
+static void my_array_rs_time_t_comb(array_rs_time_t *accum, const array_rs_time_t *other) { }
+static void my_array_rs_time_t_out(int *out, const array_rs_time_t *accum) { }
+
+#pragma rs reduce(my_rs_tm) accumulator(my_rs_tm_accum) combiner(my_rs_tm_comb) outconverter(my_rs_tm_out)
+static void my_rs_tm_accum(rs_tm *accum, int val) { }
+static void my_rs_tm_comb(rs_tm *accum, const rs_tm *other) { }
+static void my_rs_tm_out(int *out, const rs_tm *accum) { }
+
+#pragma rs reduce(my_array_rs_tm) accumulator(my_array_rs_tm_accum) combiner(my_array_rs_tm_comb) outconverter(my_array_rs_tm_out)
+typedef rs_tm array_rs_tm[7];
+static void my_array_rs_tm_accum(array_rs_tm *accum, int val) { }
+static void my_array_rs_tm_comb(array_rs_tm *accum, const array_rs_tm *other) { }
+static void my_array_rs_tm_out(int *out, const array_rs_tm *accum) { }
+
+#pragma rs reduce(my_MyEnum) accumulator(my_MyEnum_accum) combiner(my_MyEnum_comb) outconverter(my_MyEnum_out)
+static void my_MyEnum_accum(MyEnum *accum, int val) { }
+static void my_MyEnum_comb(MyEnum *accum, const MyEnum *other) { }
+static void my_MyEnum_out(int *out, const MyEnum *accum) { }
+
+#pragma rs reduce(my_array_MyEnum) accumulator(my_array_MyEnum_accum) combiner(my_array_MyEnum_comb) outconverter(my_array_MyEnum_out)
+typedef MyEnum array_MyEnum[7];
+static void my_array_MyEnum_accum(array_MyEnum *accum, int val) { }
+static void my_array_MyEnum_comb(array_MyEnum *accum, const array_MyEnum *other) { }
+static void my_array_MyEnum_out(int *out, const array_MyEnum *accum) { }
+
+#pragma rs reduce(my_MyPtrArray) accumulator(my_MyPtrArray_accum) combiner(my_MyPtrArray_comb) outconverter(my_MyPtrArray_out)
+static void my_MyPtrArray_accum(MyPtrArray *accum, int val) { }
+static void my_MyPtrArray_comb(MyPtrArray *accum, const MyPtrArray *other) { }
+static void my_MyPtrArray_out(int *out, const MyPtrArray *accum) { }
+
+#pragma rs reduce(my_array_MyPtrArray) accumulator(my_array_MyPtrArray_accum) combiner(my_array_MyPtrArray_comb) outconverter(my_array_MyPtrArray_out)
+typedef MyPtrArray array_MyPtrArray[7];
+static void my_array_MyPtrArray_accum(array_MyPtrArray *accum, int val) { }
+static void my_array_MyPtrArray_comb(array_MyPtrArray *accum, const array_MyPtrArray *other) { }
+static void my_array_MyPtrArray_out(int *out, const array_MyPtrArray *accum) { }
+
+#pragma rs reduce(my_MyPtrFn) accumulator(my_MyPtrFn_accum) combiner(my_MyPtrFn_comb) outconverter(my_MyPtrFn_out)
+static void my_MyPtrFn_accum(MyPtrFn *accum, int val) { }
+static void my_MyPtrFn_comb(MyPtrFn *accum, const MyPtrFn *other) { }
+static void my_MyPtrFn_out(int *out, const MyPtrFn *accum) { }
+
+#pragma rs reduce(my_array_MyPtrFn) accumulator(my_array_MyPtrFn_accum) combiner(my_array_MyPtrFn_comb) outconverter(my_array_MyPtrFn_out)
+typedef MyPtrFn array_MyPtrFn[7];
+static void my_array_MyPtrFn_accum(array_MyPtrFn *accum, int val) { }
+static void my_array_MyPtrFn_comb(array_MyPtrFn *accum, const array_MyPtrFn *other) { }
+static void my_array_MyPtrFn_out(int *out, const array_MyPtrFn *accum) { }
+
+#pragma rs reduce(my_MyPtrIncomplete) accumulator(my_MyPtrIncomplete_accum) combiner(my_MyPtrIncomplete_comb) outconverter(my_MyPtrIncomplete_out)
+static void my_MyPtrIncomplete_accum(MyPtrIncomplete *accum, int val) { }
+static void my_MyPtrIncomplete_comb(MyPtrIncomplete *accum, const MyPtrIncomplete *other) { }
+static void my_MyPtrIncomplete_out(int *out, const MyPtrIncomplete *accum) { }
+
+#pragma rs reduce(my_array_MyPtrIncomplete) accumulator(my_array_MyPtrIncomplete_accum) combiner(my_array_MyPtrIncomplete_comb) outconverter(my_array_MyPtrIncomplete_out)
+typedef MyPtrIncomplete array_MyPtrIncomplete[7];
+static void my_array_MyPtrIncomplete_accum(array_MyPtrIncomplete *accum, int val) { }
+static void my_array_MyPtrIncomplete_comb(array_MyPtrIncomplete *accum, const array_MyPtrIncomplete *other) { }
+static void my_array_MyPtrIncomplete_out(int *out, const array_MyPtrIncomplete *accum) { }
+
+#pragma rs reduce(my_MyPtrShort) accumulator(my_MyPtrShort_accum) combiner(my_MyPtrShort_comb) outconverter(my_MyPtrShort_out)
+static void my_MyPtrShort_accum(MyPtrShort *accum, int val) { }
+static void my_MyPtrShort_comb(MyPtrShort *accum, const MyPtrShort *other) { }
+static void my_MyPtrShort_out(int *out, const MyPtrShort *accum) { }
+
+#pragma rs reduce(my_array_MyPtrShort) accumulator(my_array_MyPtrShort_accum) combiner(my_array_MyPtrShort_comb) outconverter(my_array_MyPtrShort_out)
+typedef MyPtrShort array_MyPtrShort[7];
+static void my_array_MyPtrShort_accum(array_MyPtrShort *accum, int val) { }
+static void my_array_MyPtrShort_comb(array_MyPtrShort *accum, const array_MyPtrShort *other) { }
+static void my_array_MyPtrShort_out(int *out, const array_MyPtrShort *accum) { }
+
+#pragma rs reduce(my_MyPtrVoid) accumulator(my_MyPtrVoid_accum) combiner(my_MyPtrVoid_comb) outconverter(my_MyPtrVoid_out)
+static void my_MyPtrVoid_accum(MyPtrVoid *accum, int val) { }
+static void my_MyPtrVoid_comb(MyPtrVoid *accum, const MyPtrVoid *other) { }
+static void my_MyPtrVoid_out(int *out, const MyPtrVoid *accum) { }
+
+#pragma rs reduce(my_array_MyPtrVoid) accumulator(my_array_MyPtrVoid_accum) combiner(my_array_MyPtrVoid_comb) outconverter(my_array_MyPtrVoid_out)
+typedef MyPtrVoid array_MyPtrVoid[7];
+static void my_array_MyPtrVoid_accum(array_MyPtrVoid *accum, int val) { }
+static void my_array_MyPtrVoid_comb(array_MyPtrVoid *accum, const array_MyPtrVoid *other) { }
+static void my_array_MyPtrVoid_out(int *out, const array_MyPtrVoid *accum) { }
+
+#pragma rs reduce(my_MyStruct) accumulator(my_MyStruct_accum) combiner(my_MyStruct_comb) outconverter(my_MyStruct_out)
+static void my_MyStruct_accum(MyStruct *accum, int val) { }
+static void my_MyStruct_comb(MyStruct *accum, const MyStruct *other) { }
+static void my_MyStruct_out(int *out, const MyStruct *accum) { }
+
+#pragma rs reduce(my_array_MyStruct) accumulator(my_array_MyStruct_accum) combiner(my_array_MyStruct_comb) outconverter(my_array_MyStruct_out)
+typedef MyStruct array_MyStruct[7];
+static void my_array_MyStruct_accum(array_MyStruct *accum, int val) { }
+static void my_array_MyStruct_comb(array_MyStruct *accum, const array_MyStruct *other) { }
+static void my_array_MyStruct_out(int *out, const array_MyStruct *accum) { }
+
+#pragma rs reduce(my_MyUnion) accumulator(my_MyUnion_accum) combiner(my_MyUnion_comb) outconverter(my_MyUnion_out)
+static void my_MyUnion_accum(MyUnion *accum, int val) { }
+static void my_MyUnion_comb(MyUnion *accum, const MyUnion *other) { }
+static void my_MyUnion_out(int *out, const MyUnion *accum) { }
+
+#pragma rs reduce(my_array_MyUnion) accumulator(my_array_MyUnion_accum) combiner(my_array_MyUnion_comb) outconverter(my_array_MyUnion_out)
+typedef MyUnion array_MyUnion[7];
+static void my_array_MyUnion_accum(array_MyUnion *accum, int val) { }
+static void my_array_MyUnion_comb(array_MyUnion *accum, const array_MyUnion *other) { }
+static void my_array_MyUnion_out(int *out, const array_MyUnion *accum) { }
+
+#pragma rs reduce(my_MyBlob) accumulator(my_MyBlob_accum) combiner(my_MyBlob_comb) outconverter(my_MyBlob_out)
+static void my_MyBlob_accum(MyBlob *accum, int val) { }
+static void my_MyBlob_comb(MyBlob *accum, const MyBlob *other) { }
+static void my_MyBlob_out(int *out, const MyBlob *accum) { }
+
+#pragma rs reduce(my_array_MyBlob) accumulator(my_array_MyBlob_accum) combiner(my_array_MyBlob_comb) outconverter(my_array_MyBlob_out)
+typedef MyBlob array_MyBlob[7];
+static void my_array_MyBlob_accum(array_MyBlob *accum, int val) { }
+static void my_array_MyBlob_comb(array_MyBlob *accum, const array_MyBlob *other) { }
+static void my_array_MyBlob_out(int *out, const array_MyBlob *accum) { }
diff --git a/tests/P_reduce_general_accumulator/stderr.txt.expect b/tests/P_reduce_general_accumulator/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_reduce_general_accumulator/stderr.txt.expect
diff --git a/tests/P_reduce_general_accumulator/stdout.txt.expect b/tests/P_reduce_general_accumulator/stdout.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_reduce_general_accumulator/stdout.txt.expect
diff --git a/tests/P_reduce_general_input/ScriptC_reduce_general_input.java.expect b/tests/P_reduce_general_input/ScriptC_reduce_general_input.java.expect
index e27acf7..64e86c8 100644
--- a/tests/P_reduce_general_input/ScriptC_reduce_general_input.java.expect
+++ b/tests/P_reduce_general_input/ScriptC_reduce_general_input.java.expect
@@ -126,6 +126,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_0 = 0;
+    // in1 = "in"
+    public result_int reduce_my_half_0(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_0(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_0(Allocation ain1) {
         return reduce_my_half_0(ain1, null);
@@ -144,6 +157,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_1 = 1;
+    // in1 = "in"
+    public result_int reduce_my_half_1(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_1(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_1(Allocation ain1) {
         return reduce_my_half_1(ain1, null);
@@ -162,6 +188,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_2 = 2;
+    // in1 = "in"
+    public result_int reduce_my_half_2(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_2(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_2(Allocation ain1) {
         return reduce_my_half_2(ain1, null);
@@ -180,6 +219,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_3 = 3;
+    // in1 = "in"
+    public result_int reduce_my_half_3(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_3(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_3(Allocation ain1) {
         return reduce_my_half_3(ain1, null);
@@ -198,6 +250,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_4 = 4;
+    // in1 = "in"
+    public result_int reduce_my_half_4(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_4(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_4(Allocation ain1) {
         return reduce_my_half_4(ain1, null);
@@ -216,6 +281,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_5 = 5;
+    // in1 = "in"
+    public result_int reduce_my_half_5(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_5(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_5(Allocation ain1) {
         return reduce_my_half_5(ain1, null);
@@ -234,6 +312,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_6 = 6;
+    // in1 = "in"
+    public result_int reduce_my_half_6(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_6(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_6(Allocation ain1) {
         return reduce_my_half_6(ain1, null);
@@ -252,6 +343,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_7 = 7;
+    // in1 = "in"
+    public result_int reduce_my_half_7(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_7(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_7(Allocation ain1) {
         return reduce_my_half_7(ain1, null);
@@ -270,6 +374,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_8 = 8;
+    // in1 = "in"
+    public result_int reduce_my_half_8(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_8(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_8(Allocation ain1) {
         return reduce_my_half_8(ain1, null);
@@ -288,6 +405,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_9 = 9;
+    // in1 = "in"
+    public result_int reduce_my_half_9(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_9(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_9(Allocation ain1) {
         return reduce_my_half_9(ain1, null);
@@ -306,6 +436,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_10 = 10;
+    // in1 = "in"
+    public result_int reduce_my_half_10(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_10(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_10(Allocation ain1) {
         return reduce_my_half_10(ain1, null);
@@ -324,6 +467,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_11 = 11;
+    // in1 = "in"
+    public result_int reduce_my_half_11(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_11(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_11(Allocation ain1) {
         return reduce_my_half_11(ain1, null);
@@ -342,6 +498,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_12 = 12;
+    // in1 = "in"
+    public result_int reduce_my_half_12(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_12(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_12(Allocation ain1) {
         return reduce_my_half_12(ain1, null);
@@ -360,6 +529,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_13 = 13;
+    // in1 = "in"
+    public result_int reduce_my_half_13(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_13(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_13(Allocation ain1) {
         return reduce_my_half_13(ain1, null);
@@ -378,6 +560,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_14 = 14;
+    // in1 = "in"
+    public result_int reduce_my_half_14(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_14(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_14(Allocation ain1) {
         return reduce_my_half_14(ain1, null);
@@ -396,6 +591,19 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_15 = 15;
+    // in1 = "in"
+    public result_int reduce_my_half_15(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half_15(ain1, null);
+    }
+
     // ain1 = "half in"
     public result_int reduce_my_half_15(Allocation ain1) {
         return reduce_my_half_15(ain1, null);
@@ -414,6 +622,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_0 = 16;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_0(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_0(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_0(Allocation ain1) {
         return reduce_my_half2_0(ain1, null);
@@ -432,6 +657,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_1 = 17;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_1(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_1(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_1(Allocation ain1) {
         return reduce_my_half2_1(ain1, null);
@@ -450,6 +692,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_2 = 18;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_2(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_2(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_2(Allocation ain1) {
         return reduce_my_half2_2(ain1, null);
@@ -468,6 +727,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_3 = 19;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_3(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_3(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_3(Allocation ain1) {
         return reduce_my_half2_3(ain1, null);
@@ -486,6 +762,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_4 = 20;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_4(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_4(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_4(Allocation ain1) {
         return reduce_my_half2_4(ain1, null);
@@ -504,6 +797,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_5 = 21;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_5(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_5(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_5(Allocation ain1) {
         return reduce_my_half2_5(ain1, null);
@@ -522,6 +832,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_6 = 22;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_6(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_6(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_6(Allocation ain1) {
         return reduce_my_half2_6(ain1, null);
@@ -540,6 +867,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_7 = 23;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_7(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_7(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_7(Allocation ain1) {
         return reduce_my_half2_7(ain1, null);
@@ -558,6 +902,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_8 = 24;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_8(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_8(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_8(Allocation ain1) {
         return reduce_my_half2_8(ain1, null);
@@ -576,6 +937,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_9 = 25;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_9(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_9(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_9(Allocation ain1) {
         return reduce_my_half2_9(ain1, null);
@@ -594,6 +972,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_10 = 26;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_10(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_10(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_10(Allocation ain1) {
         return reduce_my_half2_10(ain1, null);
@@ -612,6 +1007,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_11 = 27;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_11(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_11(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_11(Allocation ain1) {
         return reduce_my_half2_11(ain1, null);
@@ -630,6 +1042,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_12 = 28;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_12(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_12(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_12(Allocation ain1) {
         return reduce_my_half2_12(ain1, null);
@@ -648,6 +1077,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_13 = 29;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_13(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_13(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_13(Allocation ain1) {
         return reduce_my_half2_13(ain1, null);
@@ -666,6 +1112,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_14 = 30;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_14(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_14(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_14(Allocation ain1) {
         return reduce_my_half2_14(ain1, null);
@@ -684,6 +1147,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_15 = 31;
+    // in1 = "in", flattened 2-vectors
+    public result_int reduce_my_half2_15(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2_15(ain1, null);
+    }
+
     // ain1 = "half2 in"
     public result_int reduce_my_half2_15(Allocation ain1) {
         return reduce_my_half2_15(ain1, null);
@@ -702,6 +1182,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_0 = 32;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_0(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_0(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_0(Allocation ain1) {
         return reduce_my_half4_0(ain1, null);
@@ -720,6 +1217,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_1 = 33;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_1(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_1(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_1(Allocation ain1) {
         return reduce_my_half4_1(ain1, null);
@@ -738,6 +1252,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_2 = 34;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_2(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_2(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_2(Allocation ain1) {
         return reduce_my_half4_2(ain1, null);
@@ -756,6 +1287,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_3 = 35;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_3(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_3(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_3(Allocation ain1) {
         return reduce_my_half4_3(ain1, null);
@@ -774,6 +1322,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_4 = 36;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_4(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_4(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_4(Allocation ain1) {
         return reduce_my_half4_4(ain1, null);
@@ -792,6 +1357,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_5 = 37;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_5(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_5(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_5(Allocation ain1) {
         return reduce_my_half4_5(ain1, null);
@@ -810,6 +1392,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_6 = 38;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_6(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_6(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_6(Allocation ain1) {
         return reduce_my_half4_6(ain1, null);
@@ -828,6 +1427,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_7 = 39;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_7(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_7(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_7(Allocation ain1) {
         return reduce_my_half4_7(ain1, null);
@@ -846,6 +1462,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_8 = 40;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_8(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_8(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_8(Allocation ain1) {
         return reduce_my_half4_8(ain1, null);
@@ -864,6 +1497,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_9 = 41;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_9(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_9(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_9(Allocation ain1) {
         return reduce_my_half4_9(ain1, null);
@@ -882,6 +1532,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_10 = 42;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_10(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_10(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_10(Allocation ain1) {
         return reduce_my_half4_10(ain1, null);
@@ -900,6 +1567,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_11 = 43;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_11(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_11(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_11(Allocation ain1) {
         return reduce_my_half4_11(ain1, null);
@@ -918,6 +1602,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_12 = 44;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_12(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_12(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_12(Allocation ain1) {
         return reduce_my_half4_12(ain1, null);
@@ -936,6 +1637,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_13 = 45;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_13(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_13(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_13(Allocation ain1) {
         return reduce_my_half4_13(ain1, null);
@@ -954,6 +1672,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_14 = 46;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_14(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_14(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_14(Allocation ain1) {
         return reduce_my_half4_14(ain1, null);
@@ -972,6 +1707,23 @@ public class ScriptC_reduce_general_input extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_15 = 47;
+    // in1 = "in", flattened 4-vectors
+    public result_int reduce_my_half4_15(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4_15(ain1, null);
+    }
+
     // ain1 = "half4 in"
     public result_int reduce_my_half4_15(Allocation ain1) {
         return reduce_my_half4_15(ain1, null);
diff --git a/tests/P_reduce_general_inputs/ScriptC_reduce_general_inputs.java.expect b/tests/P_reduce_general_inputs/ScriptC_reduce_general_inputs.java.expect
index 45e4780..fee4368 100644
--- a/tests/P_reduce_general_inputs/ScriptC_reduce_general_inputs.java.expect
+++ b/tests/P_reduce_general_inputs/ScriptC_reduce_general_inputs.java.expect
@@ -98,6 +98,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_half_0 = 0;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "half b"
     public result_int reduce_my_half_half_0(Allocation ain1, Allocation ain2) {
@@ -135,6 +160,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_half_1 = 1;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "half b"
     public result_int reduce_my_half_half_1(Allocation ain1, Allocation ain2) {
@@ -172,6 +222,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_half2_0 = 2;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "half2 b"
     public result_int reduce_my_half_half2_0(Allocation ain1, Allocation ain2) {
@@ -209,6 +288,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_half2_1 = 3;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "half2 b"
     public result_int reduce_my_half_half2_1(Allocation ain1, Allocation ain2) {
@@ -246,6 +354,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_half4_0 = 4;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "half4 b"
     public result_int reduce_my_half_half4_0(Allocation ain1, Allocation ain2) {
@@ -283,6 +420,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_half4_1 = 5;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "half4 b"
     public result_int reduce_my_half_half4_1(Allocation ain1, Allocation ain2) {
@@ -320,6 +486,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_float_0 = 6;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_float_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_float_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "float b"
     public result_int reduce_my_half_float_0(Allocation ain1, Allocation ain2) {
@@ -357,6 +548,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_float_1 = 7;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_float_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_float_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "float b"
     public result_int reduce_my_half_float_1(Allocation ain1, Allocation ain2) {
@@ -394,6 +610,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_float2_0 = 8;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_float2_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_float2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "float2 b"
     public result_int reduce_my_half_float2_0(Allocation ain1, Allocation ain2) {
@@ -431,6 +676,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_float2_1 = 9;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_float2_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_float2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "float2 b"
     public result_int reduce_my_half_float2_1(Allocation ain1, Allocation ain2) {
@@ -468,6 +742,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_float4_0 = 10;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_float4_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_float4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "float4 b"
     public result_int reduce_my_half_float4_0(Allocation ain1, Allocation ain2) {
@@ -505,6 +808,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_float4_1 = 11;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_float4_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_float4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "float4 b"
     public result_int reduce_my_half_float4_1(Allocation ain1, Allocation ain2) {
@@ -542,6 +874,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_char_0 = 12;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_char_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_char_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "char b"
     public result_int reduce_my_half_char_0(Allocation ain1, Allocation ain2) {
@@ -579,6 +936,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_char_1 = 13;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_char_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_char_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "char b"
     public result_int reduce_my_half_char_1(Allocation ain1, Allocation ain2) {
@@ -616,6 +998,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_char2_0 = 14;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_char2_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_char2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "char2 b"
     public result_int reduce_my_half_char2_0(Allocation ain1, Allocation ain2) {
@@ -653,6 +1064,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_char2_1 = 15;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_char2_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_char2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "char2 b"
     public result_int reduce_my_half_char2_1(Allocation ain1, Allocation ain2) {
@@ -690,6 +1130,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_char4_0 = 16;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_char4_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_char4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "char4 b"
     public result_int reduce_my_half_char4_0(Allocation ain1, Allocation ain2) {
@@ -727,6 +1196,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_char4_1 = 17;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_char4_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_char4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "char4 b"
     public result_int reduce_my_half_char4_1(Allocation ain1, Allocation ain2) {
@@ -764,6 +1262,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_short_0 = 18;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_short_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_short_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "short b"
     public result_int reduce_my_half_short_0(Allocation ain1, Allocation ain2) {
@@ -801,6 +1324,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_short_1 = 19;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_short_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_short_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "short b"
     public result_int reduce_my_half_short_1(Allocation ain1, Allocation ain2) {
@@ -838,6 +1386,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_short2_0 = 20;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_short2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_short2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "short2 b"
     public result_int reduce_my_half_short2_0(Allocation ain1, Allocation ain2) {
@@ -875,6 +1452,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_short2_1 = 21;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_short2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_short2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "short2 b"
     public result_int reduce_my_half_short2_1(Allocation ain1, Allocation ain2) {
@@ -912,6 +1518,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_short4_0 = 22;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_short4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_short4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "short4 b"
     public result_int reduce_my_half_short4_0(Allocation ain1, Allocation ain2) {
@@ -949,6 +1584,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_short4_1 = 23;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_short4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_short4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "short4 b"
     public result_int reduce_my_half_short4_1(Allocation ain1, Allocation ain2) {
@@ -986,6 +1650,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_uchar_0 = 24;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_uchar_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_uchar_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "uchar b"
     public result_int reduce_my_half_uchar_0(Allocation ain1, Allocation ain2) {
@@ -1023,6 +1712,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_uchar_1 = 25;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_uchar_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_uchar_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "uchar b"
     public result_int reduce_my_half_uchar_1(Allocation ain1, Allocation ain2) {
@@ -1060,6 +1774,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_uchar2_0 = 26;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_uchar2_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_uchar2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_half_uchar2_0(Allocation ain1, Allocation ain2) {
@@ -1097,6 +1840,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_uchar2_1 = 27;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_uchar2_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_uchar2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_half_uchar2_1(Allocation ain1, Allocation ain2) {
@@ -1134,6 +1906,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_uchar4_0 = 28;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_uchar4_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_uchar4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_half_uchar4_0(Allocation ain1, Allocation ain2) {
@@ -1171,6 +1972,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_uchar4_1 = 29;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_uchar4_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_uchar4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_half_uchar4_1(Allocation ain1, Allocation ain2) {
@@ -1208,6 +2038,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_ushort_0 = 30;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_ushort_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_ushort_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "ushort b"
     public result_int reduce_my_half_ushort_0(Allocation ain1, Allocation ain2) {
@@ -1245,6 +2100,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_ushort_1 = 31;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_ushort_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_ushort_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "ushort b"
     public result_int reduce_my_half_ushort_1(Allocation ain1, Allocation ain2) {
@@ -1282,6 +2162,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_ushort2_0 = 32;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_ushort2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_ushort2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_half_ushort2_0(Allocation ain1, Allocation ain2) {
@@ -1319,6 +2228,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_ushort2_1 = 33;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half_ushort2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_ushort2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_half_ushort2_1(Allocation ain1, Allocation ain2) {
@@ -1356,6 +2294,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_ushort4_0 = 34;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_ushort4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_ushort4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_half_ushort4_0(Allocation ain1, Allocation ain2) {
@@ -1393,6 +2360,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_ushort4_1 = 35;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half_ushort4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_ushort4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_half_ushort4_1(Allocation ain1, Allocation ain2) {
@@ -1430,6 +2426,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_bool_0 = 36;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_bool_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __BOOLEAN, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_bool_0(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "bool b"
     public result_int reduce_my_half_bool_0(Allocation ain1, Allocation ain2) {
@@ -1467,6 +2488,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half_bool_1 = 37;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_half_bool_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __BOOLEAN, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half_bool_1(ain1, ain2, null);
+    }
+
     // ain1 = "half a"
     // ain2 = "bool b"
     public result_int reduce_my_half_bool_1(Allocation ain1, Allocation ain2) {
@@ -1646,6 +2692,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_half_0 = 42;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "half b"
     public result_int reduce_my_half2_half_0(Allocation ain1, Allocation ain2) {
@@ -1683,6 +2758,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_half_1 = 43;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "half b"
     public result_int reduce_my_half2_half_1(Allocation ain1, Allocation ain2) {
@@ -1720,6 +2824,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_half2_0 = 44;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_half2_half2_0(Allocation ain1, Allocation ain2) {
@@ -1757,6 +2894,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_half2_1 = 45;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_half2_half2_1(Allocation ain1, Allocation ain2) {
@@ -1794,6 +2964,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_half4_0 = 46;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_half2_half4_0(Allocation ain1, Allocation ain2) {
@@ -1831,6 +3034,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_half4_1 = 47;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_half2_half4_1(Allocation ain1, Allocation ain2) {
@@ -1868,6 +3104,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_float_0 = 48;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_float_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_float_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "float b"
     public result_int reduce_my_half2_float_0(Allocation ain1, Allocation ain2) {
@@ -1905,6 +3170,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_float_1 = 49;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_float_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_float_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "float b"
     public result_int reduce_my_half2_float_1(Allocation ain1, Allocation ain2) {
@@ -1942,6 +3236,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_float2_0 = 50;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_float2_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_float2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "float2 b"
     public result_int reduce_my_half2_float2_0(Allocation ain1, Allocation ain2) {
@@ -1979,6 +3306,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_float2_1 = 51;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_float2_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_float2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "float2 b"
     public result_int reduce_my_half2_float2_1(Allocation ain1, Allocation ain2) {
@@ -2016,6 +3376,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_float4_0 = 52;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_float4_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_float4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "float4 b"
     public result_int reduce_my_half2_float4_0(Allocation ain1, Allocation ain2) {
@@ -2053,6 +3446,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_float4_1 = 53;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_float4_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_float4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "float4 b"
     public result_int reduce_my_half2_float4_1(Allocation ain1, Allocation ain2) {
@@ -2090,6 +3516,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_char_0 = 54;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_char_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_char_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "char b"
     public result_int reduce_my_half2_char_0(Allocation ain1, Allocation ain2) {
@@ -2127,6 +3582,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_char_1 = 55;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_char_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_char_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "char b"
     public result_int reduce_my_half2_char_1(Allocation ain1, Allocation ain2) {
@@ -2164,6 +3648,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_char2_0 = 56;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_char2_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_char2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "char2 b"
     public result_int reduce_my_half2_char2_0(Allocation ain1, Allocation ain2) {
@@ -2201,6 +3718,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_char2_1 = 57;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_char2_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_char2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "char2 b"
     public result_int reduce_my_half2_char2_1(Allocation ain1, Allocation ain2) {
@@ -2238,6 +3788,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_char4_0 = 58;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_char4_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_char4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "char4 b"
     public result_int reduce_my_half2_char4_0(Allocation ain1, Allocation ain2) {
@@ -2275,6 +3858,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_char4_1 = 59;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_char4_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_char4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "char4 b"
     public result_int reduce_my_half2_char4_1(Allocation ain1, Allocation ain2) {
@@ -2312,6 +3928,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_short_0 = 60;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_short_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_short_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "short b"
     public result_int reduce_my_half2_short_0(Allocation ain1, Allocation ain2) {
@@ -2349,6 +3994,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_short_1 = 61;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_short_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_short_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "short b"
     public result_int reduce_my_half2_short_1(Allocation ain1, Allocation ain2) {
@@ -2386,6 +4060,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_short2_0 = 62;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_short2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_short2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "short2 b"
     public result_int reduce_my_half2_short2_0(Allocation ain1, Allocation ain2) {
@@ -2423,6 +4130,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_short2_1 = 63;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_short2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_short2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "short2 b"
     public result_int reduce_my_half2_short2_1(Allocation ain1, Allocation ain2) {
@@ -2460,6 +4200,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_short4_0 = 64;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_short4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_short4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "short4 b"
     public result_int reduce_my_half2_short4_0(Allocation ain1, Allocation ain2) {
@@ -2497,6 +4270,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_short4_1 = 65;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_short4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_short4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "short4 b"
     public result_int reduce_my_half2_short4_1(Allocation ain1, Allocation ain2) {
@@ -2534,6 +4340,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_uchar_0 = 66;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_uchar_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_uchar_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "uchar b"
     public result_int reduce_my_half2_uchar_0(Allocation ain1, Allocation ain2) {
@@ -2571,6 +4406,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_uchar_1 = 67;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_uchar_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_uchar_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "uchar b"
     public result_int reduce_my_half2_uchar_1(Allocation ain1, Allocation ain2) {
@@ -2608,6 +4472,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_uchar2_0 = 68;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_uchar2_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_uchar2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_half2_uchar2_0(Allocation ain1, Allocation ain2) {
@@ -2645,6 +4542,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_uchar2_1 = 69;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_uchar2_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_uchar2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_half2_uchar2_1(Allocation ain1, Allocation ain2) {
@@ -2682,6 +4612,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_uchar4_0 = 70;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_uchar4_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_uchar4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_half2_uchar4_0(Allocation ain1, Allocation ain2) {
@@ -2719,6 +4682,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_uchar4_1 = 71;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_uchar4_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_uchar4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_half2_uchar4_1(Allocation ain1, Allocation ain2) {
@@ -2756,6 +4752,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_ushort_0 = 72;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_ushort_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_ushort_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "ushort b"
     public result_int reduce_my_half2_ushort_0(Allocation ain1, Allocation ain2) {
@@ -2793,6 +4818,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_ushort_1 = 73;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_ushort_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_ushort_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "ushort b"
     public result_int reduce_my_half2_ushort_1(Allocation ain1, Allocation ain2) {
@@ -2830,6 +4884,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_ushort2_0 = 74;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_ushort2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_ushort2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_half2_ushort2_0(Allocation ain1, Allocation ain2) {
@@ -2867,6 +4954,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_ushort2_1 = 75;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half2_ushort2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_ushort2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_half2_ushort2_1(Allocation ain1, Allocation ain2) {
@@ -2904,6 +5024,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_ushort4_0 = 76;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_ushort4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_ushort4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_half2_ushort4_0(Allocation ain1, Allocation ain2) {
@@ -2941,6 +5094,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_ushort4_1 = 77;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half2_ushort4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_ushort4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_half2_ushort4_1(Allocation ain1, Allocation ain2) {
@@ -2978,6 +5164,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_bool_0 = 78;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_bool_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __BOOLEAN, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_bool_0(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "bool b"
     public result_int reduce_my_half2_bool_0(Allocation ain1, Allocation ain2) {
@@ -3015,6 +5230,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half2_bool_1 = 79;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_half2_bool_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __BOOLEAN, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half2_bool_1(ain1, ain2, null);
+    }
+
     // ain1 = "half2 a"
     // ain2 = "bool b"
     public result_int reduce_my_half2_bool_1(Allocation ain1, Allocation ain2) {
@@ -3194,6 +5438,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_half_0 = 84;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "half b"
     public result_int reduce_my_half4_half_0(Allocation ain1, Allocation ain2) {
@@ -3231,6 +5504,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_half_1 = 85;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "half b"
     public result_int reduce_my_half4_half_1(Allocation ain1, Allocation ain2) {
@@ -3268,6 +5570,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_half2_0 = 86;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_half4_half2_0(Allocation ain1, Allocation ain2) {
@@ -3305,6 +5640,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_half2_1 = 87;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_half4_half2_1(Allocation ain1, Allocation ain2) {
@@ -3342,6 +5710,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_half4_0 = 88;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_half4_half4_0(Allocation ain1, Allocation ain2) {
@@ -3379,6 +5780,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_half4_1 = 89;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_half4_half4_1(Allocation ain1, Allocation ain2) {
@@ -3416,6 +5850,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_float_0 = 90;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_float_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_float_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "float b"
     public result_int reduce_my_half4_float_0(Allocation ain1, Allocation ain2) {
@@ -3453,6 +5916,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_float_1 = 91;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_float_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_float_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "float b"
     public result_int reduce_my_half4_float_1(Allocation ain1, Allocation ain2) {
@@ -3490,6 +5982,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_float2_0 = 92;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_float2_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_float2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "float2 b"
     public result_int reduce_my_half4_float2_0(Allocation ain1, Allocation ain2) {
@@ -3527,6 +6052,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_float2_1 = 93;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_float2_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_float2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "float2 b"
     public result_int reduce_my_half4_float2_1(Allocation ain1, Allocation ain2) {
@@ -3564,6 +6122,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_float4_0 = 94;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_float4_0(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_float4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "float4 b"
     public result_int reduce_my_half4_float4_0(Allocation ain1, Allocation ain2) {
@@ -3601,6 +6192,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_float4_1 = 95;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_float4_1(short[] in1, float[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F32_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_float4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "float4 b"
     public result_int reduce_my_half4_float4_1(Allocation ain1, Allocation ain2) {
@@ -3638,6 +6262,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_char_0 = 96;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_char_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_char_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "char b"
     public result_int reduce_my_half4_char_0(Allocation ain1, Allocation ain2) {
@@ -3675,6 +6328,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_char_1 = 97;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_char_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_char_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "char b"
     public result_int reduce_my_half4_char_1(Allocation ain1, Allocation ain2) {
@@ -3712,6 +6394,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_char2_0 = 98;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_char2_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_char2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "char2 b"
     public result_int reduce_my_half4_char2_0(Allocation ain1, Allocation ain2) {
@@ -3749,6 +6464,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_char2_1 = 99;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_char2_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_char2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "char2 b"
     public result_int reduce_my_half4_char2_1(Allocation ain1, Allocation ain2) {
@@ -3786,6 +6534,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_char4_0 = 100;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_char4_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_char4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "char4 b"
     public result_int reduce_my_half4_char4_0(Allocation ain1, Allocation ain2) {
@@ -3823,6 +6604,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_char4_1 = 101;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_char4_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_char4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "char4 b"
     public result_int reduce_my_half4_char4_1(Allocation ain1, Allocation ain2) {
@@ -3860,6 +6674,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_short_0 = 102;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_short_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_short_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "short b"
     public result_int reduce_my_half4_short_0(Allocation ain1, Allocation ain2) {
@@ -3897,6 +6740,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_short_1 = 103;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_short_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_short_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "short b"
     public result_int reduce_my_half4_short_1(Allocation ain1, Allocation ain2) {
@@ -3934,6 +6806,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_short2_0 = 104;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_short2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_short2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "short2 b"
     public result_int reduce_my_half4_short2_0(Allocation ain1, Allocation ain2) {
@@ -3971,6 +6876,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_short2_1 = 105;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_short2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_short2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "short2 b"
     public result_int reduce_my_half4_short2_1(Allocation ain1, Allocation ain2) {
@@ -4008,6 +6946,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_short4_0 = 106;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_short4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_short4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "short4 b"
     public result_int reduce_my_half4_short4_0(Allocation ain1, Allocation ain2) {
@@ -4045,6 +7016,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_short4_1 = 107;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_short4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __I16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_short4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "short4 b"
     public result_int reduce_my_half4_short4_1(Allocation ain1, Allocation ain2) {
@@ -4082,6 +7086,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_uchar_0 = 108;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_uchar_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_uchar_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "uchar b"
     public result_int reduce_my_half4_uchar_0(Allocation ain1, Allocation ain2) {
@@ -4119,6 +7152,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_uchar_1 = 109;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_uchar_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_uchar_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "uchar b"
     public result_int reduce_my_half4_uchar_1(Allocation ain1, Allocation ain2) {
@@ -4156,6 +7218,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_uchar2_0 = 110;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_uchar2_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_uchar2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_half4_uchar2_0(Allocation ain1, Allocation ain2) {
@@ -4193,6 +7288,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_uchar2_1 = 111;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_uchar2_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_uchar2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_half4_uchar2_1(Allocation ain1, Allocation ain2) {
@@ -4230,6 +7358,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_uchar4_0 = 112;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_uchar4_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_uchar4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_half4_uchar4_0(Allocation ain1, Allocation ain2) {
@@ -4267,6 +7428,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_uchar4_1 = 113;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_uchar4_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U8_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_uchar4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_half4_uchar4_1(Allocation ain1, Allocation ain2) {
@@ -4304,6 +7498,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_ushort_0 = 114;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_ushort_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_ushort_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "ushort b"
     public result_int reduce_my_half4_ushort_0(Allocation ain1, Allocation ain2) {
@@ -4341,6 +7564,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_ushort_1 = 115;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_ushort_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_ushort_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "ushort b"
     public result_int reduce_my_half4_ushort_1(Allocation ain1, Allocation ain2) {
@@ -4378,6 +7630,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_ushort2_0 = 116;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_ushort2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_ushort2_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_half4_ushort2_0(Allocation ain1, Allocation ain2) {
@@ -4415,6 +7700,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_ushort2_1 = 117;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_half4_ushort2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_ushort2_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_half4_ushort2_1(Allocation ain1, Allocation ain2) {
@@ -4452,6 +7770,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_ushort4_0 = 118;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_ushort4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_ushort4_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_half4_ushort4_0(Allocation ain1, Allocation ain2) {
@@ -4489,6 +7840,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_ushort4_1 = 119;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_half4_ushort4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __U16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_ushort4_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_half4_ushort4_1(Allocation ain1, Allocation ain2) {
@@ -4526,6 +7910,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_bool_0 = 120;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_bool_0(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __BOOLEAN, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_bool_0(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "bool b"
     public result_int reduce_my_half4_bool_0(Allocation ain1, Allocation ain2) {
@@ -4563,6 +7976,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half4_bool_1 = 121;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_half4_bool_1(short[] in1, byte[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __BOOLEAN, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_half4_bool_1(ain1, ain2, null);
+    }
+
     // ain1 = "half4 a"
     // ain2 = "bool b"
     public result_int reduce_my_half4_bool_1(Allocation ain1, Allocation ain2) {
@@ -4742,6 +8184,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float_half_0 = 126;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_float_half_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "float a"
     // ain2 = "half b"
     public result_int reduce_my_float_half_0(Allocation ain1, Allocation ain2) {
@@ -4779,6 +8246,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float_half_1 = 127;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_float_half_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "float a"
     // ain2 = "half b"
     public result_int reduce_my_float_half_1(Allocation ain1, Allocation ain2) {
@@ -4816,6 +8308,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float_half2_0 = 128;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_float_half2_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "float a"
     // ain2 = "half2 b"
     public result_int reduce_my_float_half2_0(Allocation ain1, Allocation ain2) {
@@ -4853,6 +8374,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float_half2_1 = 129;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_float_half2_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "float a"
     // ain2 = "half2 b"
     public result_int reduce_my_float_half2_1(Allocation ain1, Allocation ain2) {
@@ -4890,6 +8440,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float_half4_0 = 130;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_float_half4_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "float a"
     // ain2 = "half4 b"
     public result_int reduce_my_float_half4_0(Allocation ain1, Allocation ain2) {
@@ -4927,6 +8506,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float_half4_1 = 131;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_float_half4_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "float a"
     // ain2 = "half4 b"
     public result_int reduce_my_float_half4_1(Allocation ain1, Allocation ain2) {
@@ -7170,6 +10778,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float2_half_0 = 168;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_float2_half_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float2_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "float2 a"
     // ain2 = "half b"
     public result_int reduce_my_float2_half_0(Allocation ain1, Allocation ain2) {
@@ -7207,6 +10844,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float2_half_1 = 169;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_float2_half_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float2_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "float2 a"
     // ain2 = "half b"
     public result_int reduce_my_float2_half_1(Allocation ain1, Allocation ain2) {
@@ -7244,6 +10910,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float2_half2_0 = 170;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_float2_half2_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float2_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "float2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_float2_half2_0(Allocation ain1, Allocation ain2) {
@@ -7281,6 +10980,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float2_half2_1 = 171;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_float2_half2_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float2_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "float2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_float2_half2_1(Allocation ain1, Allocation ain2) {
@@ -7318,6 +11050,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float2_half4_0 = 172;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_float2_half4_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float2_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "float2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_float2_half4_0(Allocation ain1, Allocation ain2) {
@@ -7355,6 +11120,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float2_half4_1 = 173;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_float2_half4_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float2_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "float2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_float2_half4_1(Allocation ain1, Allocation ain2) {
@@ -9726,6 +13524,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float4_half_0 = 210;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_float4_half_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float4_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "float4 a"
     // ain2 = "half b"
     public result_int reduce_my_float4_half_0(Allocation ain1, Allocation ain2) {
@@ -9763,6 +13590,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float4_half_1 = 211;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_float4_half_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float4_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "float4 a"
     // ain2 = "half b"
     public result_int reduce_my_float4_half_1(Allocation ain1, Allocation ain2) {
@@ -9800,6 +13656,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float4_half2_0 = 212;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_float4_half2_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float4_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "float4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_float4_half2_0(Allocation ain1, Allocation ain2) {
@@ -9837,6 +13726,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float4_half2_1 = 213;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_float4_half2_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float4_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "float4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_float4_half2_1(Allocation ain1, Allocation ain2) {
@@ -9874,6 +13796,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float4_half4_0 = 214;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_float4_half4_0(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float4_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "float4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_float4_half4_0(Allocation ain1, Allocation ain2) {
@@ -9911,6 +13866,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_float4_half4_1 = 215;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_float4_half4_1(float[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_float4_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "float4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_float4_half4_1(Allocation ain1, Allocation ain2) {
@@ -12282,6 +16270,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char_half_0 = 252;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_char_half_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "char a"
     // ain2 = "half b"
     public result_int reduce_my_char_half_0(Allocation ain1, Allocation ain2) {
@@ -12319,6 +16332,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char_half_1 = 253;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_char_half_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "char a"
     // ain2 = "half b"
     public result_int reduce_my_char_half_1(Allocation ain1, Allocation ain2) {
@@ -12356,6 +16394,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char_half2_0 = 254;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_char_half2_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "char a"
     // ain2 = "half2 b"
     public result_int reduce_my_char_half2_0(Allocation ain1, Allocation ain2) {
@@ -12393,6 +16460,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char_half2_1 = 255;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_char_half2_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "char a"
     // ain2 = "half2 b"
     public result_int reduce_my_char_half2_1(Allocation ain1, Allocation ain2) {
@@ -12430,6 +16526,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char_half4_0 = 256;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_char_half4_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "char a"
     // ain2 = "half4 b"
     public result_int reduce_my_char_half4_0(Allocation ain1, Allocation ain2) {
@@ -12467,6 +16592,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char_half4_1 = 257;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_char_half4_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "char a"
     // ain2 = "half4 b"
     public result_int reduce_my_char_half4_1(Allocation ain1, Allocation ain2) {
@@ -14710,6 +18864,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char2_half_0 = 294;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_char2_half_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char2_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "char2 a"
     // ain2 = "half b"
     public result_int reduce_my_char2_half_0(Allocation ain1, Allocation ain2) {
@@ -14747,6 +18930,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char2_half_1 = 295;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_char2_half_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char2_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "char2 a"
     // ain2 = "half b"
     public result_int reduce_my_char2_half_1(Allocation ain1, Allocation ain2) {
@@ -14784,6 +18996,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char2_half2_0 = 296;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_char2_half2_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char2_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "char2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_char2_half2_0(Allocation ain1, Allocation ain2) {
@@ -14821,6 +19066,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char2_half2_1 = 297;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_char2_half2_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char2_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "char2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_char2_half2_1(Allocation ain1, Allocation ain2) {
@@ -14858,6 +19136,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char2_half4_0 = 298;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_char2_half4_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char2_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "char2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_char2_half4_0(Allocation ain1, Allocation ain2) {
@@ -14895,6 +19206,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char2_half4_1 = 299;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_char2_half4_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char2_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "char2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_char2_half4_1(Allocation ain1, Allocation ain2) {
@@ -17266,6 +21610,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char4_half_0 = 336;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_char4_half_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char4_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "char4 a"
     // ain2 = "half b"
     public result_int reduce_my_char4_half_0(Allocation ain1, Allocation ain2) {
@@ -17303,6 +21676,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char4_half_1 = 337;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_char4_half_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char4_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "char4 a"
     // ain2 = "half b"
     public result_int reduce_my_char4_half_1(Allocation ain1, Allocation ain2) {
@@ -17340,6 +21742,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char4_half2_0 = 338;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_char4_half2_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char4_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "char4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_char4_half2_0(Allocation ain1, Allocation ain2) {
@@ -17377,6 +21812,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char4_half2_1 = 339;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_char4_half2_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char4_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "char4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_char4_half2_1(Allocation ain1, Allocation ain2) {
@@ -17414,6 +21882,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char4_half4_0 = 340;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_char4_half4_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char4_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "char4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_char4_half4_0(Allocation ain1, Allocation ain2) {
@@ -17451,6 +21952,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_char4_half4_1 = 341;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_char4_half4_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_char4_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "char4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_char4_half4_1(Allocation ain1, Allocation ain2) {
@@ -19822,6 +24356,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short_half_0 = 378;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_short_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "short a"
     // ain2 = "half b"
     public result_int reduce_my_short_half_0(Allocation ain1, Allocation ain2) {
@@ -19859,6 +24418,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short_half_1 = 379;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_short_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "short a"
     // ain2 = "half b"
     public result_int reduce_my_short_half_1(Allocation ain1, Allocation ain2) {
@@ -19896,6 +24480,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short_half2_0 = 380;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_short_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "short a"
     // ain2 = "half2 b"
     public result_int reduce_my_short_half2_0(Allocation ain1, Allocation ain2) {
@@ -19933,6 +24546,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short_half2_1 = 381;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_short_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "short a"
     // ain2 = "half2 b"
     public result_int reduce_my_short_half2_1(Allocation ain1, Allocation ain2) {
@@ -19970,6 +24612,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short_half4_0 = 382;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_short_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "short a"
     // ain2 = "half4 b"
     public result_int reduce_my_short_half4_0(Allocation ain1, Allocation ain2) {
@@ -20007,6 +24678,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short_half4_1 = 383;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_short_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "short a"
     // ain2 = "half4 b"
     public result_int reduce_my_short_half4_1(Allocation ain1, Allocation ain2) {
@@ -22250,6 +26950,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short2_half_0 = 420;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_short2_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short2_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "short2 a"
     // ain2 = "half b"
     public result_int reduce_my_short2_half_0(Allocation ain1, Allocation ain2) {
@@ -22287,6 +27016,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short2_half_1 = 421;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_short2_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short2_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "short2 a"
     // ain2 = "half b"
     public result_int reduce_my_short2_half_1(Allocation ain1, Allocation ain2) {
@@ -22324,6 +27082,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short2_half2_0 = 422;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_short2_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short2_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "short2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_short2_half2_0(Allocation ain1, Allocation ain2) {
@@ -22361,6 +27152,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short2_half2_1 = 423;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_short2_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short2_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "short2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_short2_half2_1(Allocation ain1, Allocation ain2) {
@@ -22398,6 +27222,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short2_half4_0 = 424;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_short2_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short2_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "short2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_short2_half4_0(Allocation ain1, Allocation ain2) {
@@ -22435,6 +27292,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short2_half4_1 = 425;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_short2_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short2_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "short2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_short2_half4_1(Allocation ain1, Allocation ain2) {
@@ -24806,6 +29696,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short4_half_0 = 462;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_short4_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short4_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "short4 a"
     // ain2 = "half b"
     public result_int reduce_my_short4_half_0(Allocation ain1, Allocation ain2) {
@@ -24843,6 +29762,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short4_half_1 = 463;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_short4_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short4_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "short4 a"
     // ain2 = "half b"
     public result_int reduce_my_short4_half_1(Allocation ain1, Allocation ain2) {
@@ -24880,6 +29828,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short4_half2_0 = 464;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_short4_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short4_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "short4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_short4_half2_0(Allocation ain1, Allocation ain2) {
@@ -24917,6 +29898,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short4_half2_1 = 465;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_short4_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short4_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "short4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_short4_half2_1(Allocation ain1, Allocation ain2) {
@@ -24954,6 +29968,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short4_half4_0 = 466;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_short4_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short4_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "short4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_short4_half4_0(Allocation ain1, Allocation ain2) {
@@ -24991,6 +30038,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_short4_half4_1 = 467;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_short4_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_short4_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "short4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_short4_half4_1(Allocation ain1, Allocation ain2) {
@@ -27362,6 +32442,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar_half_0 = 504;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_uchar_half_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar a"
     // ain2 = "half b"
     public result_int reduce_my_uchar_half_0(Allocation ain1, Allocation ain2) {
@@ -27399,6 +32504,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar_half_1 = 505;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_uchar_half_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar a"
     // ain2 = "half b"
     public result_int reduce_my_uchar_half_1(Allocation ain1, Allocation ain2) {
@@ -27436,6 +32566,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar_half2_0 = 506;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_uchar_half2_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar a"
     // ain2 = "half2 b"
     public result_int reduce_my_uchar_half2_0(Allocation ain1, Allocation ain2) {
@@ -27473,6 +32632,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar_half2_1 = 507;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_uchar_half2_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar a"
     // ain2 = "half2 b"
     public result_int reduce_my_uchar_half2_1(Allocation ain1, Allocation ain2) {
@@ -27510,6 +32698,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar_half4_0 = 508;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_uchar_half4_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar a"
     // ain2 = "half4 b"
     public result_int reduce_my_uchar_half4_0(Allocation ain1, Allocation ain2) {
@@ -27547,6 +32764,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar_half4_1 = 509;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_uchar_half4_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar a"
     // ain2 = "half4 b"
     public result_int reduce_my_uchar_half4_1(Allocation ain1, Allocation ain2) {
@@ -29790,6 +35036,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar2_half_0 = 546;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_uchar2_half_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar2_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar2 a"
     // ain2 = "half b"
     public result_int reduce_my_uchar2_half_0(Allocation ain1, Allocation ain2) {
@@ -29827,6 +35102,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar2_half_1 = 547;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_uchar2_half_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar2_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar2 a"
     // ain2 = "half b"
     public result_int reduce_my_uchar2_half_1(Allocation ain1, Allocation ain2) {
@@ -29864,6 +35168,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar2_half2_0 = 548;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_uchar2_half2_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar2_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_uchar2_half2_0(Allocation ain1, Allocation ain2) {
@@ -29901,6 +35238,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar2_half2_1 = 549;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_uchar2_half2_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar2_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_uchar2_half2_1(Allocation ain1, Allocation ain2) {
@@ -29938,6 +35308,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar2_half4_0 = 550;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_uchar2_half4_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar2_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_uchar2_half4_0(Allocation ain1, Allocation ain2) {
@@ -29975,6 +35378,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar2_half4_1 = 551;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_uchar2_half4_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar2_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_uchar2_half4_1(Allocation ain1, Allocation ain2) {
@@ -32346,6 +37782,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar4_half_0 = 588;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_uchar4_half_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar4_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar4 a"
     // ain2 = "half b"
     public result_int reduce_my_uchar4_half_0(Allocation ain1, Allocation ain2) {
@@ -32383,6 +37848,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar4_half_1 = 589;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_uchar4_half_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar4_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar4 a"
     // ain2 = "half b"
     public result_int reduce_my_uchar4_half_1(Allocation ain1, Allocation ain2) {
@@ -32420,6 +37914,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar4_half2_0 = 590;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_uchar4_half2_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar4_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_uchar4_half2_0(Allocation ain1, Allocation ain2) {
@@ -32457,6 +37984,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar4_half2_1 = 591;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_uchar4_half2_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar4_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_uchar4_half2_1(Allocation ain1, Allocation ain2) {
@@ -32494,6 +38054,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar4_half4_0 = 592;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_uchar4_half4_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar4_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "uchar4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_uchar4_half4_0(Allocation ain1, Allocation ain2) {
@@ -32531,6 +38124,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_uchar4_half4_1 = 593;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_uchar4_half4_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_uchar4_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "uchar4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_uchar4_half4_1(Allocation ain1, Allocation ain2) {
@@ -34902,6 +40528,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort_half_0 = 630;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_ushort_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort a"
     // ain2 = "half b"
     public result_int reduce_my_ushort_half_0(Allocation ain1, Allocation ain2) {
@@ -34939,6 +40590,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort_half_1 = 631;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_ushort_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort a"
     // ain2 = "half b"
     public result_int reduce_my_ushort_half_1(Allocation ain1, Allocation ain2) {
@@ -34976,6 +40652,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort_half2_0 = 632;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_ushort_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort a"
     // ain2 = "half2 b"
     public result_int reduce_my_ushort_half2_0(Allocation ain1, Allocation ain2) {
@@ -35013,6 +40718,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort_half2_1 = 633;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_ushort_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort a"
     // ain2 = "half2 b"
     public result_int reduce_my_ushort_half2_1(Allocation ain1, Allocation ain2) {
@@ -35050,6 +40784,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort_half4_0 = 634;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_ushort_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort a"
     // ain2 = "half4 b"
     public result_int reduce_my_ushort_half4_0(Allocation ain1, Allocation ain2) {
@@ -35087,6 +40850,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort_half4_1 = 635;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_ushort_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort a"
     // ain2 = "half4 b"
     public result_int reduce_my_ushort_half4_1(Allocation ain1, Allocation ain2) {
@@ -37330,6 +43122,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort2_half_0 = 672;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_ushort2_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort2_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort2 a"
     // ain2 = "half b"
     public result_int reduce_my_ushort2_half_0(Allocation ain1, Allocation ain2) {
@@ -37367,6 +43188,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort2_half_1 = 673;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b"
+    public result_int reduce_my_ushort2_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort2_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort2 a"
     // ain2 = "half b"
     public result_int reduce_my_ushort2_half_1(Allocation ain1, Allocation ain2) {
@@ -37404,6 +43254,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort2_half2_0 = 674;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_ushort2_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort2_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_ushort2_half2_0(Allocation ain1, Allocation ain2) {
@@ -37441,6 +43324,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort2_half2_1 = 675;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_ushort2_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort2_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_ushort2_half2_1(Allocation ain1, Allocation ain2) {
@@ -37478,6 +43394,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort2_half4_0 = 676;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_ushort2_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort2_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_ushort2_half4_0(Allocation ain1, Allocation ain2) {
@@ -37515,6 +43464,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort2_half4_1 = 677;
+    // in1 = "a", flattened 2-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_ushort2_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 2 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort2_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_ushort2_half4_1(Allocation ain1, Allocation ain2) {
@@ -39886,6 +45868,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort4_half_0 = 714;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_ushort4_half_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort4_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort4 a"
     // ain2 = "half b"
     public result_int reduce_my_ushort4_half_0(Allocation ain1, Allocation ain2) {
@@ -39923,6 +45934,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort4_half_1 = 715;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b"
+    public result_int reduce_my_ushort4_half_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort4_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort4 a"
     // ain2 = "half b"
     public result_int reduce_my_ushort4_half_1(Allocation ain1, Allocation ain2) {
@@ -39960,6 +46000,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort4_half2_0 = 716;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_ushort4_half2_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort4_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_ushort4_half2_0(Allocation ain1, Allocation ain2) {
@@ -39997,6 +46070,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort4_half2_1 = 717;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_ushort4_half2_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort4_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort4 a"
     // ain2 = "half2 b"
     public result_int reduce_my_ushort4_half2_1(Allocation ain1, Allocation ain2) {
@@ -40034,6 +46140,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort4_half4_0 = 718;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_ushort4_half4_0(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort4_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "ushort4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_ushort4_half4_0(Allocation ain1, Allocation ain2) {
@@ -40071,6 +46210,39 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_ushort4_half4_1 = 719;
+    // in1 = "a", flattened 4-vectors
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_ushort4_half4_1(short[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length / 4 != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_ushort4_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "ushort4 a"
     // ain2 = "half4 b"
     public result_int reduce_my_ushort4_half4_1(Allocation ain1, Allocation ain2) {
@@ -42442,6 +48614,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_bool_half_0 = 756;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_bool_half_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_bool_half_0(ain1, ain2, null);
+    }
+
     // ain1 = "bool a"
     // ain2 = "half b"
     public result_int reduce_my_bool_half_0(Allocation ain1, Allocation ain2) {
@@ -42479,6 +48676,31 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_bool_half_1 = 757;
+    // in1 = "a"
+    // in2 = "b"
+    public result_int reduce_my_bool_half_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16, in2.length);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_bool_half_1(ain1, ain2, null);
+    }
+
     // ain1 = "bool a"
     // ain2 = "half b"
     public result_int reduce_my_bool_half_1(Allocation ain1, Allocation ain2) {
@@ -42516,6 +48738,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_bool_half2_0 = 758;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_bool_half2_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_bool_half2_0(ain1, ain2, null);
+    }
+
     // ain1 = "bool a"
     // ain2 = "half2 b"
     public result_int reduce_my_bool_half2_0(Allocation ain1, Allocation ain2) {
@@ -42553,6 +48804,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_bool_half2_1 = 759;
+    // in1 = "a"
+    // in2 = "b", flattened 2-vectors
+    public result_int reduce_my_bool_half2_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 2 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 2) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_2, in2.length / 2);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_bool_half2_1(ain1, ain2, null);
+    }
+
     // ain1 = "bool a"
     // ain2 = "half2 b"
     public result_int reduce_my_bool_half2_1(Allocation ain1, Allocation ain2) {
@@ -42590,6 +48870,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_bool_half4_0 = 760;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_bool_half4_0(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_bool_half4_0(ain1, ain2, null);
+    }
+
     // ain1 = "bool a"
     // ain2 = "half4 b"
     public result_int reduce_my_bool_half4_0(Allocation ain1, Allocation ain2) {
@@ -42627,6 +48936,35 @@ public class ScriptC_reduce_general_inputs extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_bool_half4_1 = 761;
+    // in1 = "a"
+    // in2 = "b", flattened 4-vectors
+    public result_int reduce_my_bool_half4_1(byte[] in1, short[] in2) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+        // Verify that "in2" is non-null.
+        if (in2 == null) {
+            throw new RSIllegalArgumentException("Array \"in2\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in2.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in2\" is not a multiple of 4 in length!");
+        }
+        // Verify that input array lengths are the same.
+        if (in1.length != in2.length / 4) {
+            throw new RSRuntimeException("Array length mismatch between parameters \"in1\" and \"in2\"!");
+        }
+        Allocation ain2 = Allocation.createSized(mRSLocal, __F16_4, in2.length / 4);
+        ain2.setAutoPadding(true);
+        ain2.copyFrom(in2);
+
+        return reduce_my_bool_half4_1(ain1, ain2, null);
+    }
+
     // ain1 = "bool a"
     // ain2 = "half4 b"
     public result_int reduce_my_bool_half4_1(Allocation ain1, Allocation ain2) {
diff --git a/tests/P_reduce_general_result/ScriptC_reduce_general_result.java.expect b/tests/P_reduce_general_result/ScriptC_reduce_general_result.java.expect
index 5bbc9b0..c54160a 100644
--- a/tests/P_reduce_general_result/ScriptC_reduce_general_result.java.expect
+++ b/tests/P_reduce_general_result/ScriptC_reduce_general_result.java.expect
@@ -37,6 +37,8 @@ public class ScriptC_reduce_general_result extends ScriptC {
               reduce_general_resultBitCode.getBitCode64());
         mRSLocal = rs;
         __F16 = Element.F16(rs);
+        __F16_2 = Element.F16_2(rs);
+        __F16_4 = Element.F16_4(rs);
         __F32 = Element.F32(rs);
         __F32_2 = Element.F32_2(rs);
         __F32_4 = Element.F32_4(rs);
@@ -72,6 +74,8 @@ public class ScriptC_reduce_general_result extends ScriptC {
 
     private Element __BOOLEAN;
     private Element __F16;
+    private Element __F16_2;
+    private Element __F16_4;
     private Element __F32;
     private Element __F32_2;
     private Element __F32_4;
@@ -316,6 +320,48 @@ public class ScriptC_reduce_general_result extends ScriptC {
 
     // To obtain the result, invoke get(), which blocks
     // until the asynchronously-launched operation has completed.
+    public static class resultArray7_half2 {
+        public Short2[] get() {
+            short[] outArray = new short[14];
+            mOut.copyTo(outArray);
+            Short2[] result = new Short2[7];
+            for (int Idx = 0; Idx < 7; ++Idx) {
+                result[Idx] = new Short2(outArray[2*Idx+0], outArray[2*Idx+1]);
+            }
+
+            return result;
+        }
+
+        private  resultArray7_half2(Allocation out) {
+            mOut = out;
+        }
+
+        private Allocation mOut;
+    }
+
+    // To obtain the result, invoke get(), which blocks
+    // until the asynchronously-launched operation has completed.
+    public static class resultArray7_half4 {
+        public Short4[] get() {
+            short[] outArray = new short[28];
+            mOut.copyTo(outArray);
+            Short4[] result = new Short4[7];
+            for (int Idx = 0; Idx < 7; ++Idx) {
+                result[Idx] = new Short4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
+            }
+
+            return result;
+        }
+
+        private  resultArray7_half4(Allocation out) {
+            mOut = out;
+        }
+
+        private Allocation mOut;
+    }
+
+    // To obtain the result, invoke get(), which blocks
+    // until the asynchronously-launched operation has completed.
     public static class resultArray7_int {
         public int[] get() {
             int[] outArray = new int[7];
@@ -928,6 +974,38 @@ public class ScriptC_reduce_general_result extends ScriptC {
 
     // To obtain the result, invoke get(), which blocks
     // until the asynchronously-launched operation has completed.
+    public static class result_half2 {
+        public Short2 get() {
+            short[] outArray = new short[2];
+            mOut.copyTo(outArray);
+            return new Short2(outArray[0], outArray[1]);
+        }
+
+        private  result_half2(Allocation out) {
+            mOut = out;
+        }
+
+        private Allocation mOut;
+    }
+
+    // To obtain the result, invoke get(), which blocks
+    // until the asynchronously-launched operation has completed.
+    public static class result_half4 {
+        public Short4 get() {
+            short[] outArray = new short[4];
+            mOut.copyTo(outArray);
+            return new Short4(outArray[0], outArray[1], outArray[2], outArray[3]);
+        }
+
+        private  result_half4(Allocation out) {
+            mOut = out;
+        }
+
+        private Allocation mOut;
+    }
+
+    // To obtain the result, invoke get(), which blocks
+    // until the asynchronously-launched operation has completed.
     public static class result_int {
         public int get() {
             int[] outArray = new int[1];
@@ -1275,6 +1353,19 @@ public class ScriptC_reduce_general_result extends ScriptC {
     }
 
     private final static int mExportReduceNewIdx_my_half = 0;
+    // in1 = "val"
+    public result_half reduce_my_half(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half(ain1, null);
+    }
+
     // ain1 = "half val"
     public result_half reduce_my_half(Allocation ain1) {
         return reduce_my_half(ain1, null);
@@ -1292,7 +1383,90 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_half(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_half = 1;
+    private final static int mExportReduceNewIdx_my_half2 = 1;
+    // in1 = "val", flattened 2-vectors
+    public result_half2 reduce_my_half2(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half2(ain1, null);
+    }
+
+    // ain1 = "half2 val"
+    public result_half2 reduce_my_half2(Allocation ain1) {
+        return reduce_my_half2(ain1, null);
+    }
+
+    // ain1 = "half2 val"
+    public result_half2 reduce_my_half2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__F16_2)) {
+            throw new RSRuntimeException("Type mismatch with F16_2!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_half2, new Allocation[]{ain1}, aout, sc);
+        return new result_half2(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_half4 = 2;
+    // in1 = "val", flattened 4-vectors
+    public result_half4 reduce_my_half4(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_half4(ain1, null);
+    }
+
+    // ain1 = "half4 val"
+    public result_half4 reduce_my_half4(Allocation ain1) {
+        return reduce_my_half4(ain1, null);
+    }
+
+    // ain1 = "half4 val"
+    public result_half4 reduce_my_half4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__F16_4)) {
+            throw new RSRuntimeException("Type mismatch with F16_4!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_half4, new Allocation[]{ain1}, aout, sc);
+        return new result_half4(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_half = 3;
+    // in1 = "val"
+    public resultArray7_half reduce_my_array_half(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_half(ain1, null);
+    }
+
     // ain1 = "half val"
     public resultArray7_half reduce_my_array_half(Allocation ain1) {
         return reduce_my_array_half(ain1, null);
@@ -1310,7 +1484,77 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_half(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float = 2;
+    private final static int mExportReduceNewIdx_my_array_half2 = 4;
+    // in1 = "val", flattened 2-vectors
+    public resultArray7_half2 reduce_my_array_half2(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 2 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_half2(ain1, null);
+    }
+
+    // ain1 = "half2 val"
+    public resultArray7_half2 reduce_my_array_half2(Allocation ain1) {
+        return reduce_my_array_half2(ain1, null);
+    }
+
+    // ain1 = "half2 val"
+    public resultArray7_half2 reduce_my_array_half2(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__F16_2)) {
+            throw new RSRuntimeException("Type mismatch with F16_2!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 7);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_half2, new Allocation[]{ain1}, aout, sc);
+        return new resultArray7_half2(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_array_half4 = 5;
+    // in1 = "val", flattened 4-vectors
+    public resultArray7_half4 reduce_my_array_half4(short[] in1) {
+        // Verify that "in1" is non-null.
+        if (in1 == null) {
+            throw new RSIllegalArgumentException("Array \"in1\" is null!");
+        }
+        // Verify that the array length is a multiple of the vector size.
+        if (in1.length % 4 != 0) {
+            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
+        }
+        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
+        ain1.setAutoPadding(true);
+        ain1.copyFrom(in1);
+
+        return reduce_my_array_half4(ain1, null);
+    }
+
+    // ain1 = "half4 val"
+    public resultArray7_half4 reduce_my_array_half4(Allocation ain1) {
+        return reduce_my_array_half4(ain1, null);
+    }
+
+    // ain1 = "half4 val"
+    public resultArray7_half4 reduce_my_array_half4(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__F16_4)) {
+            throw new RSRuntimeException("Type mismatch with F16_4!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 7);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_my_array_half4, new Allocation[]{ain1}, aout, sc);
+        return new resultArray7_half4(aout);
+    }
+
+    private final static int mExportReduceNewIdx_my_float = 6;
     // in1 = "val"
     public result_float reduce_my_float(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1341,7 +1585,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_float(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2 = 3;
+    private final static int mExportReduceNewIdx_my_float2 = 7;
     // in1 = "val", flattened 2-vectors
     public result_float2 reduce_my_float2(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1376,7 +1620,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_float2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4 = 4;
+    private final static int mExportReduceNewIdx_my_float4 = 8;
     // in1 = "val", flattened 4-vectors
     public result_float4 reduce_my_float4(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1411,7 +1655,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_float4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float = 5;
+    private final static int mExportReduceNewIdx_my_array_float = 9;
     // in1 = "val"
     public resultArray7_float reduce_my_array_float(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1442,7 +1686,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_float(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float2 = 6;
+    private final static int mExportReduceNewIdx_my_array_float2 = 10;
     // in1 = "val", flattened 2-vectors
     public resultArray7_float2 reduce_my_array_float2(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1477,7 +1721,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_float2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float4 = 7;
+    private final static int mExportReduceNewIdx_my_array_float4 = 11;
     // in1 = "val", flattened 4-vectors
     public resultArray7_float4 reduce_my_array_float4(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1512,7 +1756,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_float4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double = 8;
+    private final static int mExportReduceNewIdx_my_double = 12;
     // in1 = "val"
     public result_double reduce_my_double(double[] in1) {
         // Verify that "in1" is non-null.
@@ -1543,7 +1787,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_double(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2 = 9;
+    private final static int mExportReduceNewIdx_my_double2 = 13;
     // in1 = "val", flattened 2-vectors
     public result_double2 reduce_my_double2(double[] in1) {
         // Verify that "in1" is non-null.
@@ -1578,7 +1822,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_double2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4 = 10;
+    private final static int mExportReduceNewIdx_my_double4 = 14;
     // in1 = "val", flattened 4-vectors
     public result_double4 reduce_my_double4(double[] in1) {
         // Verify that "in1" is non-null.
@@ -1613,7 +1857,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_double4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double = 11;
+    private final static int mExportReduceNewIdx_my_array_double = 15;
     // in1 = "val"
     public resultArray7_double reduce_my_array_double(double[] in1) {
         // Verify that "in1" is non-null.
@@ -1644,7 +1888,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_double(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double2 = 12;
+    private final static int mExportReduceNewIdx_my_array_double2 = 16;
     // in1 = "val", flattened 2-vectors
     public resultArray7_double2 reduce_my_array_double2(double[] in1) {
         // Verify that "in1" is non-null.
@@ -1679,7 +1923,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_double2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double4 = 13;
+    private final static int mExportReduceNewIdx_my_array_double4 = 17;
     // in1 = "val", flattened 4-vectors
     public resultArray7_double4 reduce_my_array_double4(double[] in1) {
         // Verify that "in1" is non-null.
@@ -1714,7 +1958,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_double4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char = 14;
+    private final static int mExportReduceNewIdx_my_char = 18;
     // in1 = "val"
     public result_char reduce_my_char(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -1745,7 +1989,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_char(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2 = 15;
+    private final static int mExportReduceNewIdx_my_char2 = 19;
     // in1 = "val", flattened 2-vectors
     public result_char2 reduce_my_char2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -1780,7 +2024,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_char2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4 = 16;
+    private final static int mExportReduceNewIdx_my_char4 = 20;
     // in1 = "val", flattened 4-vectors
     public result_char4 reduce_my_char4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -1815,7 +2059,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_char4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char = 17;
+    private final static int mExportReduceNewIdx_my_array_char = 21;
     // in1 = "val"
     public resultArray7_char reduce_my_array_char(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -1846,7 +2090,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_char(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char2 = 18;
+    private final static int mExportReduceNewIdx_my_array_char2 = 22;
     // in1 = "val", flattened 2-vectors
     public resultArray7_char2 reduce_my_array_char2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -1881,7 +2125,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_char2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char4 = 19;
+    private final static int mExportReduceNewIdx_my_array_char4 = 23;
     // in1 = "val", flattened 4-vectors
     public resultArray7_char4 reduce_my_array_char4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -1916,7 +2160,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_char4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short = 20;
+    private final static int mExportReduceNewIdx_my_short = 24;
     // in1 = "val"
     public result_short reduce_my_short(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1947,7 +2191,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_short(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2 = 21;
+    private final static int mExportReduceNewIdx_my_short2 = 25;
     // in1 = "val", flattened 2-vectors
     public result_short2 reduce_my_short2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1982,7 +2226,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_short2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4 = 22;
+    private final static int mExportReduceNewIdx_my_short4 = 26;
     // in1 = "val", flattened 4-vectors
     public result_short4 reduce_my_short4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2017,7 +2261,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_short4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short = 23;
+    private final static int mExportReduceNewIdx_my_array_short = 27;
     // in1 = "val"
     public resultArray7_short reduce_my_array_short(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2048,7 +2292,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_short(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short2 = 24;
+    private final static int mExportReduceNewIdx_my_array_short2 = 28;
     // in1 = "val", flattened 2-vectors
     public resultArray7_short2 reduce_my_array_short2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2083,7 +2327,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_short2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short4 = 25;
+    private final static int mExportReduceNewIdx_my_array_short4 = 29;
     // in1 = "val", flattened 4-vectors
     public resultArray7_short4 reduce_my_array_short4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2118,7 +2362,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_short4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int = 26;
+    private final static int mExportReduceNewIdx_my_int = 30;
     // in1 = "val"
     public result_int reduce_my_int(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2149,7 +2393,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2 = 27;
+    private final static int mExportReduceNewIdx_my_int2 = 31;
     // in1 = "val", flattened 2-vectors
     public result_int2 reduce_my_int2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2184,7 +2428,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4 = 28;
+    private final static int mExportReduceNewIdx_my_int4 = 32;
     // in1 = "val", flattened 4-vectors
     public result_int4 reduce_my_int4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2219,7 +2463,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_int4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int = 29;
+    private final static int mExportReduceNewIdx_my_array_int = 33;
     // in1 = "val"
     public resultArray7_int reduce_my_array_int(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2250,7 +2494,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int2 = 30;
+    private final static int mExportReduceNewIdx_my_array_int2 = 34;
     // in1 = "val", flattened 2-vectors
     public resultArray7_int2 reduce_my_array_int2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2285,7 +2529,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int4 = 31;
+    private final static int mExportReduceNewIdx_my_array_int4 = 35;
     // in1 = "val", flattened 4-vectors
     public resultArray7_int4 reduce_my_array_int4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2320,7 +2564,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_int4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long = 32;
+    private final static int mExportReduceNewIdx_my_long = 36;
     // in1 = "val"
     public result_long reduce_my_long(long[] in1) {
         // Verify that "in1" is non-null.
@@ -2351,7 +2595,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_long(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2 = 33;
+    private final static int mExportReduceNewIdx_my_long2 = 37;
     // in1 = "val", flattened 2-vectors
     public result_long2 reduce_my_long2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -2386,7 +2630,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_long2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4 = 34;
+    private final static int mExportReduceNewIdx_my_long4 = 38;
     // in1 = "val", flattened 4-vectors
     public result_long4 reduce_my_long4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -2421,7 +2665,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_long4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long = 35;
+    private final static int mExportReduceNewIdx_my_array_long = 39;
     // in1 = "val"
     public resultArray7_long reduce_my_array_long(long[] in1) {
         // Verify that "in1" is non-null.
@@ -2452,7 +2696,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_long(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long2 = 36;
+    private final static int mExportReduceNewIdx_my_array_long2 = 40;
     // in1 = "val", flattened 2-vectors
     public resultArray7_long2 reduce_my_array_long2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -2487,7 +2731,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_long2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long4 = 37;
+    private final static int mExportReduceNewIdx_my_array_long4 = 41;
     // in1 = "val", flattened 4-vectors
     public resultArray7_long4 reduce_my_array_long4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -2522,7 +2766,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_long4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar = 38;
+    private final static int mExportReduceNewIdx_my_uchar = 42;
     // in1 = "val"
     public result_uchar reduce_my_uchar(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -2553,7 +2797,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_uchar(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2 = 39;
+    private final static int mExportReduceNewIdx_my_uchar2 = 43;
     // in1 = "val", flattened 2-vectors
     public result_uchar2 reduce_my_uchar2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -2588,7 +2832,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_uchar2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4 = 40;
+    private final static int mExportReduceNewIdx_my_uchar4 = 44;
     // in1 = "val", flattened 4-vectors
     public result_uchar4 reduce_my_uchar4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -2623,7 +2867,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_uchar4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar = 41;
+    private final static int mExportReduceNewIdx_my_array_uchar = 45;
     // in1 = "val"
     public resultArray7_uchar reduce_my_array_uchar(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -2654,7 +2898,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_uchar(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar2 = 42;
+    private final static int mExportReduceNewIdx_my_array_uchar2 = 46;
     // in1 = "val", flattened 2-vectors
     public resultArray7_uchar2 reduce_my_array_uchar2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -2689,7 +2933,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_uchar2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar4 = 43;
+    private final static int mExportReduceNewIdx_my_array_uchar4 = 47;
     // in1 = "val", flattened 4-vectors
     public resultArray7_uchar4 reduce_my_array_uchar4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -2724,7 +2968,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_uchar4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort = 44;
+    private final static int mExportReduceNewIdx_my_ushort = 48;
     // in1 = "val"
     public result_ushort reduce_my_ushort(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2755,7 +2999,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_ushort(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2 = 45;
+    private final static int mExportReduceNewIdx_my_ushort2 = 49;
     // in1 = "val", flattened 2-vectors
     public result_ushort2 reduce_my_ushort2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2790,7 +3034,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_ushort2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4 = 46;
+    private final static int mExportReduceNewIdx_my_ushort4 = 50;
     // in1 = "val", flattened 4-vectors
     public result_ushort4 reduce_my_ushort4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2825,7 +3069,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_ushort4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort = 47;
+    private final static int mExportReduceNewIdx_my_array_ushort = 51;
     // in1 = "val"
     public resultArray7_ushort reduce_my_array_ushort(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2856,7 +3100,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_ushort(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort2 = 48;
+    private final static int mExportReduceNewIdx_my_array_ushort2 = 52;
     // in1 = "val", flattened 2-vectors
     public resultArray7_ushort2 reduce_my_array_ushort2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2891,7 +3135,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_ushort2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort4 = 49;
+    private final static int mExportReduceNewIdx_my_array_ushort4 = 53;
     // in1 = "val", flattened 4-vectors
     public resultArray7_ushort4 reduce_my_array_ushort4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2926,7 +3170,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_ushort4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint = 50;
+    private final static int mExportReduceNewIdx_my_uint = 54;
     // in1 = "val"
     public result_uint reduce_my_uint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2957,7 +3201,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_uint(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2 = 51;
+    private final static int mExportReduceNewIdx_my_uint2 = 55;
     // in1 = "val", flattened 2-vectors
     public result_uint2 reduce_my_uint2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2992,7 +3236,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_uint2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4 = 52;
+    private final static int mExportReduceNewIdx_my_uint4 = 56;
     // in1 = "val", flattened 4-vectors
     public result_uint4 reduce_my_uint4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3027,7 +3271,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_uint4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint = 53;
+    private final static int mExportReduceNewIdx_my_array_uint = 57;
     // in1 = "val"
     public resultArray7_uint reduce_my_array_uint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3058,7 +3302,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_uint(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint2 = 54;
+    private final static int mExportReduceNewIdx_my_array_uint2 = 58;
     // in1 = "val", flattened 2-vectors
     public resultArray7_uint2 reduce_my_array_uint2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3093,7 +3337,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_uint2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint4 = 55;
+    private final static int mExportReduceNewIdx_my_array_uint4 = 59;
     // in1 = "val", flattened 4-vectors
     public resultArray7_uint4 reduce_my_array_uint4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3128,7 +3372,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_uint4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong = 56;
+    private final static int mExportReduceNewIdx_my_ulong = 60;
     // in1 = "val"
     public result_ulong reduce_my_ulong(long[] in1) {
         // Verify that "in1" is non-null.
@@ -3159,7 +3403,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_ulong(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2 = 57;
+    private final static int mExportReduceNewIdx_my_ulong2 = 61;
     // in1 = "val", flattened 2-vectors
     public result_ulong2 reduce_my_ulong2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -3194,7 +3438,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_ulong2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4 = 58;
+    private final static int mExportReduceNewIdx_my_ulong4 = 62;
     // in1 = "val", flattened 4-vectors
     public result_ulong4 reduce_my_ulong4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -3229,7 +3473,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_ulong4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong = 59;
+    private final static int mExportReduceNewIdx_my_array_ulong = 63;
     // in1 = "val"
     public resultArray7_ulong reduce_my_array_ulong(long[] in1) {
         // Verify that "in1" is non-null.
@@ -3260,7 +3504,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_ulong(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong2 = 60;
+    private final static int mExportReduceNewIdx_my_array_ulong2 = 64;
     // in1 = "val", flattened 2-vectors
     public resultArray7_ulong2 reduce_my_array_ulong2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -3295,7 +3539,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_ulong2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong4 = 61;
+    private final static int mExportReduceNewIdx_my_array_ulong4 = 65;
     // in1 = "val", flattened 4-vectors
     public resultArray7_ulong4 reduce_my_array_ulong4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -3330,7 +3574,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new resultArray7_ulong4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool = 62;
+    private final static int mExportReduceNewIdx_my_bool = 66;
     // in1 = "val"
     public result_bool reduce_my_bool(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -3361,7 +3605,7 @@ public class ScriptC_reduce_general_result extends ScriptC {
         return new result_bool(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_bool = 63;
+    private final static int mExportReduceNewIdx_my_array_bool = 67;
     // in1 = "val"
     public resultArray7_bool reduce_my_array_bool(byte[] in1) {
         // Verify that "in1" is non-null.
diff --git a/tests/P_reduce_general_result/gen-result.pl b/tests/P_reduce_general_result/gen-result.pl
index 417b6b8..a042625 100755
--- a/tests/P_reduce_general_result/gen-result.pl
+++ b/tests/P_reduce_general_result/gen-result.pl
@@ -31,9 +31,6 @@ foreach my $basicType (@basicTypes) {
       # There are no bool vectors or struct vectors
       next if ($vecLen > 1) && (($basicType eq "bool") || ($basicType eq "MyStruct"));
 
-      # We do not support half vectors as reduction results
-      next if ($vecLen > 1) && ($basicType eq "half");
-
       my $eltName = $basicType;
       $eltName .= $vecLen if ($vecLen > 1);
       my $resultName = ($isArray ? "array_${eltName}" : $eltName);
diff --git a/tests/P_reduce_general_result/reduce_general_result.rs b/tests/P_reduce_general_result/reduce_general_result.rs
index 8f2c59a..8e0ba2b 100644
--- a/tests/P_reduce_general_result/reduce_general_result.rs
+++ b/tests/P_reduce_general_result/reduce_general_result.rs
@@ -14,11 +14,29 @@ typedef struct MyStruct { float f; double d; } MyStruct;
 static void my_half_accum(half *accum, half val) { }
 static void my_half_comb(half *accum, const half *other) { }
 
+#pragma rs reduce(my_half2) accumulator(my_half2_accum) combiner(my_half2_comb)
+static void my_half2_accum(half2 *accum, half2 val) { }
+static void my_half2_comb(half2 *accum, const half2 *other) { }
+
+#pragma rs reduce(my_half4) accumulator(my_half4_accum) combiner(my_half4_comb)
+static void my_half4_accum(half4 *accum, half4 val) { }
+static void my_half4_comb(half4 *accum, const half4 *other) { }
+
 #pragma rs reduce(my_array_half) accumulator(my_array_half_accum) combiner(my_array_half_comb)
 typedef half array_half[7];
 static void my_array_half_accum(array_half *accum, half val) { }
 static void my_array_half_comb(array_half *accum, const array_half *other) { }
 
+#pragma rs reduce(my_array_half2) accumulator(my_array_half2_accum) combiner(my_array_half2_comb)
+typedef half2 array_half2[7];
+static void my_array_half2_accum(array_half2 *accum, half2 val) { }
+static void my_array_half2_comb(array_half2 *accum, const array_half2 *other) { }
+
+#pragma rs reduce(my_array_half4) accumulator(my_array_half4_accum) combiner(my_array_half4_comb)
+typedef half4 array_half4[7];
+static void my_array_half4_accum(array_half4 *accum, half4 val) { }
+static void my_array_half4_comb(array_half4 *accum, const array_half4 *other) { }
+
 #pragma rs reduce(my_float) accumulator(my_float_accum) combiner(my_float_comb)
 static void my_float_accum(float *accum, float val) { }
 static void my_float_comb(float *accum, const float *other) { }
diff --git a/tests/P_reduce_general_struct/ScriptC_reduce_general_struct.java.expect b/tests/P_reduce_general_struct/ScriptC_reduce_general_struct.java.expect
new file mode 100644
index 0000000..8650005
--- /dev/null
+++ b/tests/P_reduce_general_struct/ScriptC_reduce_general_struct.java.expect
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2011-2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This file is auto-generated. DO NOT MODIFY!
+ * The source Renderscript file: reduce_general_struct.rs
+ */
+
+package struct;
+
+import android.renderscript.*;
+import struct.reduce_general_structBitCode;
+
+/**
+ * @hide
+ */
+public class ScriptC_reduce_general_struct extends ScriptC {
+    private static final String __rs_resource_name = "reduce_general_struct";
+    // Constructor
+    public  ScriptC_reduce_general_struct(RenderScript rs) {
+        super(rs,
+              __rs_resource_name,
+              reduce_general_structBitCode.getBitCode32(),
+              reduce_general_structBitCode.getBitCode64());
+        mRSLocal = rs;
+        __I32 = Element.I32(rs);
+        __ScriptField_MyStruct = ScriptField_MyStruct.createElement(rs);
+    }
+
+    private Element __I32;
+    private Element __ScriptField_MyStruct;
+    private RenderScript mRSLocal;
+    // To obtain the result, invoke get(), which blocks
+    // until the asynchronously-launched operation has completed.
+    public static class result_int {
+        public int get() {
+            int[] outArray = new int[1];
+            mOut.copyTo(outArray);
+            return outArray[0];
+        }
+
+        private  result_int(Allocation out) {
+            mOut = out;
+        }
+
+        private Allocation mOut;
+    }
+
+    private final static int mExportReduceNewIdx_inStruct = 0;
+    // ain1 = "/* struct <> */ val"
+    public result_int reduce_inStruct(Allocation ain1) {
+        return reduce_inStruct(ain1, null);
+    }
+
+    // ain1 = "/* struct <> */ val"
+    public result_int reduce_inStruct(Allocation ain1, Script.LaunchOptions sc) {
+        // check ain1
+        if (!ain1.getType().getElement().isCompatible(__ScriptField_MyStruct)) {
+            throw new RSRuntimeException("Type mismatch with ScriptField_MyStruct!");
+        }
+        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
+        aout.setAutoPadding(true);
+        reduce(mExportReduceNewIdx_inStruct, new Allocation[]{ain1}, aout, sc);
+        return new result_int(aout);
+    }
+
+}
+
diff --git a/tests/P_reduce_general_struct/reduce_general_struct.rs b/tests/P_reduce_general_struct/reduce_general_struct.rs
new file mode 100644
index 0000000..ac6951e
--- /dev/null
+++ b/tests/P_reduce_general_struct/reduce_general_struct.rs
@@ -0,0 +1,15 @@
+// -target-api 0 -Wall
+#pragma version(1)
+#pragma rs java_package_name(struct)
+
+typedef struct MyStruct { int f; } MyStruct;
+
+// No Java array method reflection for kernel with struct input (only Allocation method reflection)
+#pragma rs reduce(inStruct) accumulator(inStructAccum) combiner(inStructComb)
+static void inStructAccum(int *accum, MyStruct val) { }
+static void inStructComb(int *accum, const int *other) { }
+
+// No Java reflection at all for kernel with struct result
+#pragma rs reduce(outStruct) accumulator(outStructAccum) outconverter(outStructOut)
+static void outStructAccum(int *accum, int val) { }
+static void outStructOut(MyStruct *out, const int *accum) { }
diff --git a/tests/P_reduce_general_struct/stderr.txt.expect b/tests/P_reduce_general_struct/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_reduce_general_struct/stderr.txt.expect
diff --git a/tests/P_reduce_general_struct/stdout.txt.expect b/tests/P_reduce_general_struct/stdout.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_reduce_general_struct/stdout.txt.expect