diff --git a/lit-tests/reduce_reflection/reduce_reflection.rs b/lit-tests/reduce_reflection/reduce_reflection.rs
deleted file mode 100644
index 93e850b..0000000
--- a/lit-tests/reduce_reflection/reduce_reflection.rs
+++ /dev/null
@@ -1,542 +0,0 @@
-// RUN: %Slang -target-api 0 %s
-// RUN: %scriptc-filecheck-wrapper --lang=Java %s
-
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-// CHECK: mExportReduceIdx_mul_half
-// Array variants of kernels with the half type are unsupported.
-// CHECK-NOT: reduce_mul_half({{.*}} in[],
-// CHECK: public void reduce_mul_half(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_half(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-half __attribute__((kernel("reduce"))) mul_half(half lhs, half rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_half2
-// CHECK-NOT: reduce_mul_half2({{.*}} in[],
-// CHECK: public void reduce_mul_half2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_half2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-half2 __attribute__((kernel("reduce"))) mul_half2(half2 lhs, half2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_half3
-// CHECK-NOT: reduce_mul_half3({{.*}} in[],
-// CHECK: public void reduce_mul_half3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_half3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-half3 __attribute__((kernel("reduce"))) mul_half3(half3 lhs, half3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_half4
-// CHECK-NOT: reduce_mul_half4({{.*}} in[],
-// CHECK: public void reduce_mul_half4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_half4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-half4 __attribute__((kernel("reduce"))) mul_half4(half4 lhs, half4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_bool
-// CHECK: public boolean reduce_mul_bool(byte[] in)
-// CHECK: public boolean reduce_mul_bool(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_bool(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_bool(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-bool __attribute__((kernel("reduce")))
-mul_bool(bool lhs, bool rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_char
-// CHECK: public byte reduce_mul_char(byte[] in)
-// CHECK: public byte reduce_mul_char(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_char(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_char(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-char __attribute__((kernel("reduce")))
-mul_char(char lhs, char rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_char2
-// CHECK: public Byte2 reduce_mul_char2(byte[] in)
-// CHECK: public Byte2 reduce_mul_char2(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_char2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_char2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-char2 __attribute__((kernel("reduce")))
-mul_char2(char2 lhs, char2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_char3
-// CHECK: public Byte3 reduce_mul_char3(byte[] in)
-// CHECK: public Byte3 reduce_mul_char3(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_char3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_char3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-char3 __attribute__((kernel("reduce")))
-mul_char3(char3 lhs, char3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_char4
-// CHECK: public Byte4 reduce_mul_char4(byte[] in)
-// CHECK: public Byte4 reduce_mul_char4(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_char4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_char4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-char4 __attribute__((kernel("reduce")))
-mul_char4(char4 lhs, char4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_double
-// CHECK: public double reduce_mul_double(double[] in)
-// CHECK: public double reduce_mul_double(double[] in, int x1, int x2)
-// CHECK: public void reduce_mul_double(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_double(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-double __attribute__((kernel("reduce")))
-mul_double(double lhs, double rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_double2
-// CHECK: public Double2 reduce_mul_double2(double[] in)
-// CHECK: public Double2 reduce_mul_double2(double[] in, int x1, int x2)
-// CHECK: public void reduce_mul_double2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_double2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-double2 __attribute__((kernel("reduce")))
-mul_double2(double2 lhs, double2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_double3
-// CHECK: public Double3 reduce_mul_double3(double[] in)
-// CHECK: public Double3 reduce_mul_double3(double[] in, int x1, int x2)
-// CHECK: public void reduce_mul_double3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_double3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-double3 __attribute__((kernel("reduce")))
-mul_double3(double3 lhs, double3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_double4
-// CHECK: public Double4 reduce_mul_double4(double[] in)
-// CHECK: public Double4 reduce_mul_double4(double[] in, int x1, int x2)
-// CHECK: public void reduce_mul_double4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_double4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-double4 __attribute__((kernel("reduce")))
-mul_double4(double4 lhs, double4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_float
-// CHECK: public float reduce_mul_float(float[] in)
-// CHECK: public float reduce_mul_float(float[] in, int x1, int x2)
-// CHECK: public void reduce_mul_float(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_float(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-float __attribute__((kernel("reduce")))
-mul_float(float lhs, float rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_float2
-// CHECK: public Float2 reduce_mul_float2(float[] in)
-// CHECK: public Float2 reduce_mul_float2(float[] in, int x1, int x2)
-// CHECK: public void reduce_mul_float2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_float2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-float2 __attribute__((kernel("reduce")))
-mul_float2(float2 lhs, float2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_float3
-// CHECK: public Float3 reduce_mul_float3(float[] in)
-// CHECK: public Float3 reduce_mul_float3(float[] in, int x1, int x2)
-// CHECK: public void reduce_mul_float3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_float3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-float3 __attribute__((kernel("reduce")))
-mul_float3(float3 lhs, float3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_float4
-// CHECK: public Float4 reduce_mul_float4(float[] in)
-// CHECK: public Float4 reduce_mul_float4(float[] in, int x1, int x2)
-// CHECK: public void reduce_mul_float4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_float4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-float4 __attribute__((kernel("reduce")))
-mul_float4(float4 lhs, float4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_int
-// CHECK: public int reduce_mul_int(int[] in)
-// CHECK: public int reduce_mul_int(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_int(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_int(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-int __attribute__((kernel("reduce")))
-mul_int(int lhs, int rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_int2
-// CHECK: public Int2 reduce_mul_int2(int[] in)
-// CHECK: public Int2 reduce_mul_int2(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_int2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_int2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-int2 __attribute__((kernel("reduce")))
-mul_int2(int2 lhs, int2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_int3
-// CHECK: public Int3 reduce_mul_int3(int[] in)
-// CHECK: public Int3 reduce_mul_int3(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_int3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_int3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-int3 __attribute__((kernel("reduce")))
-mul_int3(int3 lhs, int3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_int4
-// CHECK: public Int4 reduce_mul_int4(int[] in)
-// CHECK: public Int4 reduce_mul_int4(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_int4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_int4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-int4 __attribute__((kernel("reduce")))
-mul_int4(int4 lhs, int4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_long
-// CHECK: public long reduce_mul_long(long[] in)
-// CHECK: public long reduce_mul_long(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_long(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_long(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-long __attribute__((kernel("reduce")))
-mul_long(long lhs, long rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_long2
-// CHECK: public Long2 reduce_mul_long2(long[] in)
-// CHECK: public Long2 reduce_mul_long2(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_long2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_long2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-long2 __attribute__((kernel("reduce")))
-mul_long2(long2 lhs, long2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_long3
-// CHECK: public Long3 reduce_mul_long3(long[] in)
-// CHECK: public Long3 reduce_mul_long3(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_long3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_long3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-long3 __attribute__((kernel("reduce")))
-mul_long3(long3 lhs, long3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_long4
-// CHECK: public Long4 reduce_mul_long4(long[] in)
-// CHECK: public Long4 reduce_mul_long4(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_long4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_long4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-long4 __attribute__((kernel("reduce")))
-mul_long4(long4 lhs, long4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_short
-// CHECK: public short reduce_mul_short(short[] in)
-// CHECK: public short reduce_mul_short(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_short(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_short(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-short __attribute__((kernel("reduce")))
-mul_short(short lhs, short rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_short2
-// CHECK: public Short2 reduce_mul_short2(short[] in)
-// CHECK: public Short2 reduce_mul_short2(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_short2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_short2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-short2 __attribute__((kernel("reduce")))
-mul_short2(short2 lhs, short2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_short3
-// CHECK: public Short3 reduce_mul_short3(short[] in)
-// CHECK: public Short3 reduce_mul_short3(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_short3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_short3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-short3 __attribute__((kernel("reduce")))
-mul_short3(short3 lhs, short3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_short4
-// CHECK: public Short4 reduce_mul_short4(short[] in)
-// CHECK: public Short4 reduce_mul_short4(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_short4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_short4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-short4 __attribute__((kernel("reduce")))
-mul_short4(short4 lhs, short4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uchar
-// CHECK: public short reduce_mul_uchar(byte[] in)
-// CHECK: public short reduce_mul_uchar(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uchar(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uchar(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uchar __attribute__((kernel("reduce")))
-mul_uchar(uchar lhs, uchar rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uchar2
-// CHECK: public Short2 reduce_mul_uchar2(byte[] in)
-// CHECK: public Short2 reduce_mul_uchar2(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uchar2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uchar2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uchar2 __attribute__((kernel("reduce")))
-mul_uchar2(uchar2 lhs, uchar2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uchar3
-// CHECK: public Short3 reduce_mul_uchar3(byte[] in)
-// CHECK: public Short3 reduce_mul_uchar3(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uchar3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uchar3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uchar3 __attribute__((kernel("reduce")))
-mul_uchar3(uchar3 lhs, uchar3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uchar4
-// CHECK: public Short4 reduce_mul_uchar4(byte[] in)
-// CHECK: public Short4 reduce_mul_uchar4(byte[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uchar4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uchar4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uchar4 __attribute__((kernel("reduce")))
-mul_uchar4(uchar4 lhs, uchar4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uint
-// CHECK: public long reduce_mul_uint(int[] in)
-// CHECK: public long reduce_mul_uint(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uint(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uint(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uint __attribute__((kernel("reduce")))
-mul_uint(uint lhs, uint rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uint2
-// CHECK: public Long2 reduce_mul_uint2(int[] in)
-// CHECK: public Long2 reduce_mul_uint2(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uint2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uint2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uint2 __attribute__((kernel("reduce")))
-mul_uint2(uint2 lhs, uint2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uint3
-// CHECK: public Long3 reduce_mul_uint3(int[] in)
-// CHECK: public Long3 reduce_mul_uint3(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uint3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uint3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uint3 __attribute__((kernel("reduce")))
-mul_uint3(uint3 lhs, uint3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_uint4
-// CHECK: public Long4 reduce_mul_uint4(int[] in)
-// CHECK: public Long4 reduce_mul_uint4(int[] in, int x1, int x2)
-// CHECK: public void reduce_mul_uint4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_uint4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-uint4 __attribute__((kernel("reduce")))
-mul_uint4(uint4 lhs, uint4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ulong
-// CHECK: public long reduce_mul_ulong(long[] in)
-// CHECK: public long reduce_mul_ulong(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ulong(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ulong(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ulong __attribute__((kernel("reduce")))
-mul_ulong(ulong lhs, ulong rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ulong2
-// CHECK: public Long2 reduce_mul_ulong2(long[] in)
-// CHECK: public Long2 reduce_mul_ulong2(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ulong2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ulong2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ulong2 __attribute__((kernel("reduce")))
-mul_ulong2(ulong2 lhs, ulong2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ulong3
-// CHECK: public Long3 reduce_mul_ulong3(long[] in)
-// CHECK: public Long3 reduce_mul_ulong3(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ulong3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ulong3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ulong3 __attribute__((kernel("reduce")))
-mul_ulong3(ulong3 lhs, ulong3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ulong4
-// CHECK: public Long4 reduce_mul_ulong4(long[] in)
-// CHECK: public Long4 reduce_mul_ulong4(long[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ulong4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ulong4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ulong4 __attribute__((kernel("reduce")))
-mul_ulong4(ulong4 lhs, ulong4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ushort
-// CHECK: public int reduce_mul_ushort(short[] in)
-// CHECK: public int reduce_mul_ushort(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ushort(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ushort(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ushort __attribute__((kernel("reduce")))
-mul_ushort(ushort lhs, ushort rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ushort2
-// CHECK: public Int2 reduce_mul_ushort2(short[] in)
-// CHECK: public Int2 reduce_mul_ushort2(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ushort2(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ushort2(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ushort2 __attribute__((kernel("reduce")))
-mul_ushort2(ushort2 lhs, ushort2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ushort3
-// CHECK: public Int3 reduce_mul_ushort3(short[] in)
-// CHECK: public Int3 reduce_mul_ushort3(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ushort3(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ushort3(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ushort3 __attribute__((kernel("reduce")))
-mul_ushort3(ushort3 lhs, ushort3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: mExportReduceIdx_mul_ushort4
-// CHECK: public Int4 reduce_mul_ushort4(short[] in)
-// CHECK: public Int4 reduce_mul_ushort4(short[] in, int x1, int x2)
-// CHECK: public void reduce_mul_ushort4(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_ushort4(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-ushort4 __attribute__((kernel("reduce")))
-mul_ushort4(ushort4 lhs, ushort4 rhs) {
-  return lhs * rhs;
-}
-
-
-struct indirect {
-  bool elem_bool;
-  char elem_char;
-  char2 elem_char2;
-  char3 elem_char3;
-  char4 elem_char4;
-  double elem_double;
-  double2 elem_double2;
-  double3 elem_double3;
-  double4 elem_double4;
-  float elem_float;
-  float2 elem_float2;
-  float3 elem_float3;
-  float4 elem_float4;
-  int elem_int;
-  int2 elem_int2;
-  int3 elem_int3;
-  int4 elem_int4;
-  long elem_long;
-  long2 elem_long2;
-  long3 elem_long3;
-  long4 elem_long4;
-  short elem_short;
-  short2 elem_short2;
-  short3 elem_short3;
-  short4 elem_short4;
-  uchar elem_uchar;
-  uchar2 elem_uchar2;
-  uchar3 elem_uchar3;
-  uchar4 elem_uchar4;
-  uint elem_uint;
-  uint2 elem_uint2;
-  uint3 elem_uint3;
-  uint4 elem_uint4;
-  ulong elem_ulong;
-  ulong2 elem_ulong2;
-  ulong3 elem_ulong3;
-  ulong4 elem_ulong4;
-  ushort elem_ushort;
-  ushort2 elem_ushort2;
-  ushort3 elem_ushort3;
-  ushort4 elem_ushort4;
-};
-
-// CHECK: mExportReduceIdx_mul_indirect
-// CHECK: public void reduce_mul_indirect(Allocation ain, Allocation aout)
-// CHECK: public void reduce_mul_indirect(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-struct indirect __attribute__((kernel("reduce")))
-mul_indirect(struct indirect lhs, struct indirect rhs) {
-  lhs.elem_bool *= rhs.elem_bool;
-  lhs.elem_char *= rhs.elem_char;
-  lhs.elem_char2 *= rhs.elem_char2;
-  lhs.elem_char3 *= rhs.elem_char3;
-  lhs.elem_char4 *= rhs.elem_char4;
-  lhs.elem_double *= rhs.elem_double;
-  lhs.elem_double2 *= rhs.elem_double2;
-  lhs.elem_double3 *= rhs.elem_double3;
-  lhs.elem_double4 *= rhs.elem_double4;
-  lhs.elem_float *= rhs.elem_float;
-  lhs.elem_float2 *= rhs.elem_float2;
-  lhs.elem_float3 *= rhs.elem_float3;
-  lhs.elem_float4 *= rhs.elem_float4;
-  lhs.elem_int *= rhs.elem_int;
-  lhs.elem_int2 *= rhs.elem_int2;
-  lhs.elem_int3 *= rhs.elem_int3;
-  lhs.elem_int4 *= rhs.elem_int4;
-  lhs.elem_long *= rhs.elem_long;
-  lhs.elem_long2 *= rhs.elem_long2;
-  lhs.elem_long3 *= rhs.elem_long3;
-  lhs.elem_long4 *= rhs.elem_long4;
-  lhs.elem_short *= rhs.elem_short;
-  lhs.elem_short2 *= rhs.elem_short2;
-  lhs.elem_short3 *= rhs.elem_short3;
-  lhs.elem_short4 *= rhs.elem_short4;
-  lhs.elem_uchar *= rhs.elem_uchar;
-  lhs.elem_uchar2 *= rhs.elem_uchar2;
-  lhs.elem_uchar3 *= rhs.elem_uchar3;
-  lhs.elem_uchar4 *= rhs.elem_uchar4;
-  lhs.elem_uint *= rhs.elem_uint;
-  lhs.elem_uint2 *= rhs.elem_uint2;
-  lhs.elem_uint3 *= rhs.elem_uint3;
-  lhs.elem_uint4 *= rhs.elem_uint4;
-  lhs.elem_ulong *= rhs.elem_ulong;
-  lhs.elem_ulong2 *= rhs.elem_ulong2;
-  lhs.elem_ulong3 *= rhs.elem_ulong3;
-  lhs.elem_ulong4 *= rhs.elem_ulong4;
-  lhs.elem_ushort *= rhs.elem_ushort;
-  lhs.elem_ushort2 *= rhs.elem_ushort2;
-  lhs.elem_ushort3 *= rhs.elem_ushort3;
-  lhs.elem_ushort4 *= rhs.elem_ushort4;
-  return lhs;
-}
diff --git a/lit-tests/reduce_reflection/reduce_reflection_cpp.rs b/lit-tests/reduce_reflection/reduce_reflection_cpp.rs
deleted file mode 100644
index 0da4d0a..0000000
--- a/lit-tests/reduce_reflection/reduce_reflection_cpp.rs
+++ /dev/null
@@ -1,408 +0,0 @@
-// RUN: %Slang -target-api 0 -reflect-c++ %s
-// RUN: %scriptc-filecheck-wrapper --lang=C++ %s
-
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-// CHECK: void reduce_mul_half(android::RSC::sp<android::RSC::Allocation> ain,
-// Array variants of kernels with the half type are unsupported.
-// CHECK-NOT: half reduce_mul_half(const half in[],
-half __attribute__((kernel("reduce"))) mul_half(half lhs, half rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_half2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK-NOT: Half2 reduce_mul_half2(const half in[],
-half2 __attribute__((kernel("reduce"))) mul_half2(half2 lhs, half2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_half3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK-NOT: Half3 reduce_mul_half3(const half in[],
-half3 __attribute__((kernel("reduce"))) mul_half3(half3 lhs, half3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_half4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK-NOT: Half4 reduce_mul_half4(const half in[],
-half4 __attribute__((kernel("reduce"))) mul_half4(half4 lhs, half4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_bool(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: bool reduce_mul_bool(const bool in[],
-bool __attribute__((kernel("reduce")))
-mul_bool(bool lhs, bool rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_char(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: int8_t reduce_mul_char(const int8_t in[],
-char __attribute__((kernel("reduce")))
-mul_char(char lhs, char rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_char2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Byte2 reduce_mul_char2(const int8_t in[],
-char2 __attribute__((kernel("reduce")))
-mul_char2(char2 lhs, char2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_char3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Byte3 reduce_mul_char3(const int8_t in[],
-char3 __attribute__((kernel("reduce")))
-mul_char3(char3 lhs, char3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_char4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Byte4 reduce_mul_char4(const int8_t in[],
-char4 __attribute__((kernel("reduce")))
-mul_char4(char4 lhs, char4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_double(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: double reduce_mul_double(const double in[],
-double __attribute__((kernel("reduce")))
-mul_double(double lhs, double rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_double2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Double2 reduce_mul_double2(const double in[],
-double2 __attribute__((kernel("reduce")))
-mul_double2(double2 lhs, double2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_double3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Double3 reduce_mul_double3(const double in[],
-double3 __attribute__((kernel("reduce")))
-mul_double3(double3 lhs, double3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_double4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Double4 reduce_mul_double4(const double in[],
-double4 __attribute__((kernel("reduce")))
-mul_double4(double4 lhs, double4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_float(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: float reduce_mul_float(const float in[],
-float __attribute__((kernel("reduce")))
-mul_float(float lhs, float rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_float2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Float2 reduce_mul_float2(const float in[],
-float2 __attribute__((kernel("reduce")))
-mul_float2(float2 lhs, float2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_float3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Float3 reduce_mul_float3(const float in[],
-float3 __attribute__((kernel("reduce")))
-mul_float3(float3 lhs, float3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_float4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Float4 reduce_mul_float4(const float in[],
-float4 __attribute__((kernel("reduce")))
-mul_float4(float4 lhs, float4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_int(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: int32_t reduce_mul_int(const int32_t in[],
-int __attribute__((kernel("reduce")))
-mul_int(int lhs, int rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_int2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Int2 reduce_mul_int2(const int32_t in[],
-int2 __attribute__((kernel("reduce")))
-mul_int2(int2 lhs, int2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_int3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Int3 reduce_mul_int3(const int32_t in[],
-int3 __attribute__((kernel("reduce")))
-mul_int3(int3 lhs, int3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_int4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Int4 reduce_mul_int4(const int32_t in[],
-int4 __attribute__((kernel("reduce")))
-mul_int4(int4 lhs, int4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_long(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: int64_t reduce_mul_long(const int64_t in[],
-long __attribute__((kernel("reduce")))
-mul_long(long lhs, long rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_long2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Long2 reduce_mul_long2(const int64_t in[],
-long2 __attribute__((kernel("reduce")))
-mul_long2(long2 lhs, long2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_long3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Long3 reduce_mul_long3(const int64_t in[],
-long3 __attribute__((kernel("reduce")))
-mul_long3(long3 lhs, long3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_long4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Long4 reduce_mul_long4(const int64_t in[],
-long4 __attribute__((kernel("reduce")))
-mul_long4(long4 lhs, long4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_short(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: int16_t reduce_mul_short(const int16_t in[],
-short __attribute__((kernel("reduce")))
-mul_short(short lhs, short rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_short2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Short2 reduce_mul_short2(const int16_t in[],
-short2 __attribute__((kernel("reduce")))
-mul_short2(short2 lhs, short2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_short3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Short3 reduce_mul_short3(const int16_t in[],
-short3 __attribute__((kernel("reduce")))
-mul_short3(short3 lhs, short3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_short4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: Short4 reduce_mul_short4(const int16_t in[],
-short4 __attribute__((kernel("reduce")))
-mul_short4(short4 lhs, short4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uchar(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: uint8_t reduce_mul_uchar(const uint8_t in[],
-uchar __attribute__((kernel("reduce")))
-mul_uchar(uchar lhs, uchar rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uchar2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UByte2 reduce_mul_uchar2(const uint8_t in[],
-uchar2 __attribute__((kernel("reduce")))
-mul_uchar2(uchar2 lhs, uchar2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uchar3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UByte3 reduce_mul_uchar3(const uint8_t in[],
-uchar3 __attribute__((kernel("reduce")))
-mul_uchar3(uchar3 lhs, uchar3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uchar4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UByte4 reduce_mul_uchar4(const uint8_t in[],
-uchar4 __attribute__((kernel("reduce")))
-mul_uchar4(uchar4 lhs, uchar4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uint(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: uint32_t reduce_mul_uint(const uint32_t in[],
-uint __attribute__((kernel("reduce")))
-mul_uint(uint lhs, uint rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uint2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UInt2 reduce_mul_uint2(const uint32_t in[],
-uint2 __attribute__((kernel("reduce")))
-mul_uint2(uint2 lhs, uint2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uint3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UInt3 reduce_mul_uint3(const uint32_t in[],
-uint3 __attribute__((kernel("reduce")))
-mul_uint3(uint3 lhs, uint3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_uint4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UInt4 reduce_mul_uint4(const uint32_t in[],
-uint4 __attribute__((kernel("reduce")))
-mul_uint4(uint4 lhs, uint4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ulong(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: uint64_t reduce_mul_ulong(const uint64_t in[],
-ulong __attribute__((kernel("reduce")))
-mul_ulong(ulong lhs, ulong rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ulong2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: ULong2 reduce_mul_ulong2(const uint64_t in[],
-ulong2 __attribute__((kernel("reduce")))
-mul_ulong2(ulong2 lhs, ulong2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ulong3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: ULong3 reduce_mul_ulong3(const uint64_t in[],
-ulong3 __attribute__((kernel("reduce")))
-mul_ulong3(ulong3 lhs, ulong3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ulong4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: ULong4 reduce_mul_ulong4(const uint64_t in[],
-ulong4 __attribute__((kernel("reduce")))
-mul_ulong4(ulong4 lhs, ulong4 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ushort(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: uint16_t reduce_mul_ushort(const uint16_t in[],
-ushort __attribute__((kernel("reduce")))
-mul_ushort(ushort lhs, ushort rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ushort2(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UShort2 reduce_mul_ushort2(const uint16_t in[],
-ushort2 __attribute__((kernel("reduce")))
-mul_ushort2(ushort2 lhs, ushort2 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ushort3(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UShort3 reduce_mul_ushort3(const uint16_t in[],
-ushort3 __attribute__((kernel("reduce")))
-mul_ushort3(ushort3 lhs, ushort3 rhs) {
-  return lhs * rhs;
-}
-
-// CHECK: void reduce_mul_ushort4(android::RSC::sp<android::RSC::Allocation> ain,
-// CHECK: UShort4 reduce_mul_ushort4(const uint16_t in[],
-ushort4 __attribute__((kernel("reduce")))
-mul_ushort4(ushort4 lhs, ushort4 rhs) {
-  return lhs * rhs;
-}
-
-struct indirect {
-  bool elem_bool;
-  char elem_char;
-  char2 elem_char2;
-  char3 elem_char3;
-  char4 elem_char4;
-  double elem_double;
-  double2 elem_double2;
-  double3 elem_double3;
-  double4 elem_double4;
-  float elem_float;
-  float2 elem_float2;
-  float3 elem_float3;
-  float4 elem_float4;
-  int elem_int;
-  int2 elem_int2;
-  int3 elem_int3;
-  int4 elem_int4;
-  long elem_long;
-  long2 elem_long2;
-  long3 elem_long3;
-  long4 elem_long4;
-  short elem_short;
-  short2 elem_short2;
-  short3 elem_short3;
-  short4 elem_short4;
-  uchar elem_uchar;
-  uchar2 elem_uchar2;
-  uchar3 elem_uchar3;
-  uchar4 elem_uchar4;
-  uint elem_uint;
-  uint2 elem_uint2;
-  uint3 elem_uint3;
-  uint4 elem_uint4;
-  ulong elem_ulong;
-  ulong2 elem_ulong2;
-  ulong3 elem_ulong3;
-  ulong4 elem_ulong4;
-  ushort elem_ushort;
-  ushort2 elem_ushort2;
-  ushort3 elem_ushort3;
-  ushort4 elem_ushort4;
-};
-
-// CHECK: void reduce_mul_indirect(android::RSC::sp<android::RSC::Allocation> ain,
-struct indirect __attribute__((kernel("reduce")))
-mul_indirect(struct indirect lhs, struct indirect rhs) {
-  lhs.elem_bool *= rhs.elem_bool;
-  lhs.elem_char *= rhs.elem_char;
-  lhs.elem_char2 *= rhs.elem_char2;
-  lhs.elem_char3 *= rhs.elem_char3;
-  lhs.elem_char4 *= rhs.elem_char4;
-  lhs.elem_double *= rhs.elem_double;
-  lhs.elem_double2 *= rhs.elem_double2;
-  lhs.elem_double3 *= rhs.elem_double3;
-  lhs.elem_double4 *= rhs.elem_double4;
-  lhs.elem_float *= rhs.elem_float;
-  lhs.elem_float2 *= rhs.elem_float2;
-  lhs.elem_float3 *= rhs.elem_float3;
-  lhs.elem_float4 *= rhs.elem_float4;
-  lhs.elem_int *= rhs.elem_int;
-  lhs.elem_int2 *= rhs.elem_int2;
-  lhs.elem_int3 *= rhs.elem_int3;
-  lhs.elem_int4 *= rhs.elem_int4;
-  lhs.elem_long *= rhs.elem_long;
-  lhs.elem_long2 *= rhs.elem_long2;
-  lhs.elem_long3 *= rhs.elem_long3;
-  lhs.elem_long4 *= rhs.elem_long4;
-  lhs.elem_short *= rhs.elem_short;
-  lhs.elem_short2 *= rhs.elem_short2;
-  lhs.elem_short3 *= rhs.elem_short3;
-  lhs.elem_short4 *= rhs.elem_short4;
-  lhs.elem_uchar *= rhs.elem_uchar;
-  lhs.elem_uchar2 *= rhs.elem_uchar2;
-  lhs.elem_uchar3 *= rhs.elem_uchar3;
-  lhs.elem_uchar4 *= rhs.elem_uchar4;
-  lhs.elem_uint *= rhs.elem_uint;
-  lhs.elem_uint2 *= rhs.elem_uint2;
-  lhs.elem_uint3 *= rhs.elem_uint3;
-  lhs.elem_uint4 *= rhs.elem_uint4;
-  lhs.elem_ulong *= rhs.elem_ulong;
-  lhs.elem_ulong2 *= rhs.elem_ulong2;
-  lhs.elem_ulong3 *= rhs.elem_ulong3;
-  lhs.elem_ulong4 *= rhs.elem_ulong4;
-  lhs.elem_ushort *= rhs.elem_ushort;
-  lhs.elem_ushort2 *= rhs.elem_ushort2;
-  lhs.elem_ushort3 *= rhs.elem_ushort3;
-  lhs.elem_ushort4 *= rhs.elem_ushort4;
-  return lhs;
-}
diff --git a/slang_backend.cpp b/slang_backend.cpp
index cb17cb4..81de4fd 100644
--- a/slang_backend.cpp
+++ b/slang_backend.cpp
@@ -221,7 +221,7 @@
       mIsFilterscript(IsFilterscript), mExportVarMetadata(nullptr),
       mExportFuncMetadata(nullptr), mExportForEachNameMetadata(nullptr),
       mExportForEachSignatureMetadata(nullptr),
-      mExportReduceNewMetadata(nullptr),
+      mExportReduceMetadata(nullptr),
       mExportTypeMetadata(nullptr), mRSObjectSlotsMetadata(nullptr),
       mRefCount(mContext->getASTContext()),
       mASTChecker(Context, Context->getTargetAPI(), IsFilterscript),
@@ -771,21 +771,21 @@
   }
 }
 
-void Backend::dumpExportReduceNewInfo(llvm::Module *M) {
-  if (!mExportReduceNewMetadata) {
-    mExportReduceNewMetadata =
-      M->getOrInsertNamedMetadata(RS_EXPORT_REDUCE_NEW_MN);
+void Backend::dumpExportReduceInfo(llvm::Module *M) {
+  if (!mExportReduceMetadata) {
+    mExportReduceMetadata =
+      M->getOrInsertNamedMetadata(RS_EXPORT_REDUCE_MN);
   }
 
-  llvm::SmallVector<llvm::Metadata *, 6> ExportReduceNewInfo;
-  // Add operand to ExportReduceNewInfo, padding out missing operands with
+  llvm::SmallVector<llvm::Metadata *, 6> ExportReduceInfo;
+  // Add operand to ExportReduceInfo, padding out missing operands with
   // nullptr.
-  auto addOperand = [&ExportReduceNewInfo](uint32_t Idx, llvm::Metadata *N) {
-    while (Idx > ExportReduceNewInfo.size())
-      ExportReduceNewInfo.push_back(nullptr);
-    ExportReduceNewInfo.push_back(N);
+  auto addOperand = [&ExportReduceInfo](uint32_t Idx, llvm::Metadata *N) {
+    while (Idx > ExportReduceInfo.size())
+      ExportReduceInfo.push_back(nullptr);
+    ExportReduceInfo.push_back(N);
   };
-  // Add string operand to ExportReduceNewInfo, padding out missing operands
+  // Add string operand to ExportReduceInfo, padding out missing operands
   // with nullptr.
   // If string is empty, then do not add it unless Always is true.
   auto addString = [&addOperand, this](uint32_t Idx, const std::string &S,
@@ -795,10 +795,10 @@
   };
 
   // Add the description of the reduction kernels to the metadata node.
-  for (auto I = mContext->export_reduce_new_begin(),
-            E = mContext->export_reduce_new_end();
+  for (auto I = mContext->export_reduce_begin(),
+            E = mContext->export_reduce_end();
        I != E; ++I) {
-    ExportReduceNewInfo.clear();
+    ExportReduceInfo.clear();
 
     int Idx = 0;
 
@@ -819,8 +819,8 @@
     addString(Idx++, (*I)->getNameOutConverter(), false);
     addString(Idx++, (*I)->getNameHalter(), false);
 
-    mExportReduceNewMetadata->addOperand(
-      llvm::MDTuple::get(mLLVMContext, ExportReduceNewInfo));
+    mExportReduceMetadata->addOperand(
+      llvm::MDTuple::get(mLLVMContext, ExportReduceInfo));
   }
 }
 
@@ -901,8 +901,8 @@
   if (mContext->hasExportForEach())
     dumpExportForEachInfo(M);
 
-  if (mContext->hasExportReduceNew())
-    dumpExportReduceNewInfo(M);
+  if (mContext->hasExportReduce())
+    dumpExportReduceInfo(M);
 
   if (mContext->hasExportType())
     dumpExportTypeInfo(M);
diff --git a/slang_backend.h b/slang_backend.h
index 72519ae..38aa1e4 100644
--- a/slang_backend.h
+++ b/slang_backend.h
@@ -98,7 +98,7 @@
   llvm::NamedMDNode *mExportFuncMetadata;
   llvm::NamedMDNode *mExportForEachNameMetadata;
   llvm::NamedMDNode *mExportForEachSignatureMetadata;
-  llvm::NamedMDNode *mExportReduceNewMetadata;
+  llvm::NamedMDNode *mExportReduceMetadata;
   llvm::NamedMDNode *mExportTypeMetadata;
   llvm::NamedMDNode *mRSObjectSlotsMetadata;
 
@@ -113,7 +113,7 @@
   void dumpExportVarInfo(llvm::Module *M);
   void dumpExportFunctionInfo(llvm::Module *M);
   void dumpExportForEachInfo(llvm::Module *M);
-  void dumpExportReduceNewInfo(llvm::Module *M);
+  void dumpExportReduceInfo(llvm::Module *M);
   void dumpExportTypeInfo(llvm::Module *M);
 
   // Translates any rsForEach() or rsForEachWithOptions() calls inside the body
diff --git a/slang_rs_check_ast.cpp b/slang_rs_check_ast.cpp
index b24831a..52626bc 100644
--- a/slang_rs_check_ast.cpp
+++ b/slang_rs_check_ast.cpp
@@ -167,7 +167,7 @@
     llvm::StringRef KernelKind =
       FD->getAttr<clang::KernelAttr>()->getKernelKind();
 
-    if (!KernelKind.empty() && !KernelKind.equals("reduce")) {
+    if (!KernelKind.empty()) {
       Context->ReportError(FD->getLocation(),
                            "Unknown kernel attribute argument '%0' "
                            "in declaration of function '%1'")
@@ -197,8 +197,7 @@
   }
 
   bool saveKernel = mInKernel;
-  mInKernel = RSExportForEach::isRSForEachFunc(mTargetAPI, FD) ||
-              RSExportReduce::isRSReduceFunc(mTargetAPI, FD);
+  mInKernel = RSExportForEach::isRSForEachFunc(mTargetAPI, FD);
 
   if (clang::Stmt *Body = FD->getBody()) {
     Visit(Body);
diff --git a/slang_rs_context.cpp b/slang_rs_context.cpp
index 4c7971d..0e3ee53 100644
--- a/slang_rs_context.cpp
+++ b/slang_rs_context.cpp
@@ -148,15 +148,6 @@
     return true;
   }
 
-  // Reduce kernel
-  if (RSExportReduce::isRSReduceFunc(mTargetAPI, FD)) {
-    if (auto *ER = RSExportReduce::Create(this, FD)) {
-      mExportReduce.push_back(ER);
-      return true;
-    }
-    return false;
-  }
-
   // Invokable
   if (auto *EF = RSExportFunc::Create(this, FD)) {
     mExportFuncs.push_back(EF);
@@ -319,7 +310,7 @@
     BE->HandleTopLevelDecl(clang::DeclGroupRef(DummyVar));
 
   bool valid = true;
-  for (auto I = export_reduce_new_begin(), E = export_reduce_new_end(); I != E; ++I) {
+  for (auto I = export_reduce_begin(), E = export_reduce_end(); I != E; ++I) {
     if (! (*I)->analyzeTranslationUnit())
       valid = false;
   }
@@ -337,7 +328,7 @@
     // names mentioned in a reduce pragma and searchable in O(c) or
     // O(log(n)) time rather than the currently-implemented O(n) search.
     auto NameMatches = [this, FD]() {
-      for (auto I = export_reduce_new_begin(), E = export_reduce_new_end(); I != E; ++I) {
+      for (auto I = export_reduce_begin(), E = export_reduce_end(); I != E; ++I) {
         if ((*I)->matchName(FD->getName()))
           return true;
       }
diff --git a/slang_rs_context.h b/slang_rs_context.h
index 45edf3a..e6b4e8c 100644
--- a/slang_rs_context.h
+++ b/slang_rs_context.h
@@ -56,7 +56,6 @@
   class RSExportFunc;
   class RSExportForEach;
   class RSExportReduce;
-  class RSExportReduceNew;
   class RSExportType;
 
 class RSContext {
@@ -70,10 +69,9 @@
   typedef std::list<RSExportFunc*> ExportFuncList;
   typedef std::vector<RSExportForEach*> ExportForEachVector;
   typedef std::list<RSExportReduce*> ExportReduceList;
-  typedef std::list<RSExportReduceNew*> ExportReduceNewList;
 
   // WARNING: Sorted by pointer value, resulting in unpredictable order
-  typedef std::unordered_set<RSExportType*> ExportReduceNewResultTypeSet;
+  typedef std::unordered_set<RSExportType*> ExportReduceResultTypeSet;
 
   typedef llvm::StringMap<RSExportType*> ExportTypeMap;
 
@@ -119,8 +117,7 @@
   ExportForEachVector mExportForEach;
   ExportForEachVector::iterator mFirstOldStyleKernel;
   ExportReduceList mExportReduce;
-  ExportReduceNewList mExportReduceNew;
-  ExportReduceNewResultTypeSet mExportReduceNewResultType;
+  ExportReduceResultTypeSet mExportReduceResultType;
   ExportTypeMap mExportTypes;
 
   clang::QualType mAllocationType;
@@ -252,28 +249,19 @@
     return mExportReduce.end();
   }
   inline bool hasExportReduce() const { return !mExportReduce.empty(); }
-
-  typedef ExportReduceNewList::const_iterator const_export_reduce_new_iterator;
-  const_export_reduce_new_iterator export_reduce_new_begin() const {
-    return mExportReduceNew.begin();
-  }
-  const_export_reduce_new_iterator export_reduce_new_end() const {
-    return mExportReduceNew.end();
-  }
-  inline bool hasExportReduceNew() const { return !mExportReduceNew.empty(); }
-  void addExportReduceNew(RSExportReduceNew *ReduceNew) {
-    mExportReduceNew.push_back(ReduceNew);
+  void addExportReduce(RSExportReduce *Reduce) {
+    mExportReduce.push_back(Reduce);
   }
   bool processReducePragmas(Backend *BE);
   void markUsedByReducePragma(clang::FunctionDecl *FD, CheckName Check);
 
   // If the type has already been inserted, has no effect.
-  void insertExportReduceNewResultType(RSExportType *Type) { mExportReduceNewResultType.insert(Type); }
+  void insertExportReduceResultType(RSExportType *Type) { mExportReduceResultType.insert(Type); }
 
   template <class FilterIn, class Compare>
-  std::vector<RSExportType *> getReduceNewResultTypes(FilterIn Filt, Compare Comp) const {
+  std::vector<RSExportType *> getReduceResultTypes(FilterIn Filt, Compare Comp) const {
     std::vector<RSExportType *> Return;
-    std::copy_if(mExportReduceNewResultType.begin(), mExportReduceNewResultType.end(), std::back_inserter(Return), Filt);
+    std::copy_if(mExportReduceResultType.begin(), mExportReduceResultType.end(), std::back_inserter(Return), Filt);
     std::sort(Return.begin(), Return.end(), Comp);
     auto ReturnNewEndIter = std::unique(Return.begin(), Return.end(),
                                         [Comp](const RSExportType *a, const RSExportType *b) {
diff --git a/slang_rs_export_reduce.cpp b/slang_rs_export_reduce.cpp
index 4bb198c..7ec6e01 100644
--- a/slang_rs_export_reduce.cpp
+++ b/slang_rs_export_reduce.cpp
@@ -20,7 +20,6 @@
 #include <sstream>
 #include <string>
 
-#include "clang/AST/Attr.h"
 #include "clang/AST/ASTContext.h"
 
 #include "slang_assert.h"
@@ -32,169 +31,16 @@
 
 #include "bcinfo/MetadataExtractor.h"
 
-namespace {
-
-bool haveReduceInTargetAPI(unsigned int TargetAPI) {
-  return TargetAPI == RS_DEVELOPMENT_API;
-}
-
-} // end anonymous namespace
-
-
 namespace slang {
 
-// Validate the parameters to a reduce kernel, and set up the
-// exportable object if the kernel is valid.
-//
-// This checks that the passed function declaration of a reduce kernel is
-// a function which satisfies all the requirements for a reduce
-// kernel. Namely, we check for:
-//  - correct target API
-//  - correct parameter count
-//  - non void return type
-//  - return type and parameter types match
-//  - no pointer types in signature.
-//
-// We try to report useful errors to the user.
-//
-// On success, this function returns true and sets the fields mIns and
-// mType to point to the arguments and to the kernel type.
-//
-// If an error was detected, this function returns false.
-bool RSExportReduce::validateAndConstructParams(
-    RSContext *Context, const clang::FunctionDecl *FD) {
-  slangAssert(Context && FD);
-  bool Valid = true;
+const char RSExportReduce::KeyReduce[] = "reduce";
+const char RSExportReduce::KeyInitializer[] = "initializer";
+const char RSExportReduce::KeyAccumulator[] = "accumulator";
+const char RSExportReduce::KeyCombiner[] = "combiner";
+const char RSExportReduce::KeyOutConverter[] = "outconverter";
+const char RSExportReduce::KeyHalter[] = "halter";
 
-  clang::ASTContext &ASTCtx = FD->getASTContext();
-
-  // Validate API version.
-  if (!haveReduceInTargetAPI(Context->getTargetAPI())) {
-    Context->ReportError(FD->getLocation(),
-                         "Reduce-style kernel %0() unsupported in SDK level %1")
-      << FD->getName() << Context->getTargetAPI();
-    Valid = false;
-  }
-
-  // Validate parameter count.
-  if (FD->getNumParams() != 2) {
-    Context->ReportError(FD->getLocation(),
-                         "Reduce-style kernel %0() must take 2 parameters "
-                         "(found %1).")
-      << FD->getName() << FD->getNumParams();
-    Valid = false;
-  }
-
-  // Validate return type.
-  const clang::QualType ReturnTy = FD->getReturnType().getCanonicalType();
-
-  if (ReturnTy->isVoidType()) {
-    Context->ReportError(FD->getLocation(),
-                         "Reduce-style kernel %0() cannot return void")
-      << FD->getName();
-    Valid = false;
-  } else if (ReturnTy->isPointerType()) {
-    Context->ReportError(FD->getLocation(),
-                         "Reduce-style kernel %0() cannot return a pointer "
-                         "type: %1")
-      << FD->getName() << ReturnTy.getAsString();
-    Valid = false;
-  }
-
-  // Validate parameter types.
-  if (FD->getNumParams() == 0) {
-    return false;
-  }
-
-  const clang::ParmVarDecl &FirstParam = *FD->getParamDecl(0);
-  const clang::QualType FirstParamTy = FirstParam.getType().getCanonicalType();
-
-  for (auto PVD = FD->param_begin(), PE = FD->param_end(); PVD != PE; ++PVD) {
-    const clang::ParmVarDecl &Param = **PVD;
-    const clang::QualType ParamTy = Param.getType().getCanonicalType();
-
-    // Check that the parameter is not a pointer.
-    if (ParamTy->isPointerType()) {
-      Context->ReportError(Param.getLocation(),
-                           "Reduce-style kernel %0() cannot have "
-                           "parameter '%1' of pointer type: '%2'")
-        << FD->getName() << Param.getName() << ParamTy.getAsString();
-      Valid = false;
-    }
-
-    // Check for type mismatch between this parameter and the return type.
-    if (!ASTCtx.hasSameUnqualifiedType(ReturnTy, ParamTy)) {
-      Context->ReportError(FD->getLocation(),
-                           "Reduce-style kernel %0() return type '%1' is not "
-                           "the same type as parameter '%2' (type '%3')")
-        << FD->getName() << ReturnTy.getAsString() << Param.getName()
-        << ParamTy.getAsString();
-      Valid = false;
-    }
-
-    // Check for type mismatch between parameters. It is sufficient to check
-    // for a mismatch with the type of the first argument.
-    if (ParamTy != FirstParamTy) {
-      Context->ReportError(FirstParam.getLocation(),
-                           "In reduce-style kernel %0(): parameter '%1' "
-                           "(type '%2') does not have the same type as "
-                           "parameter '%3' (type '%4')")
-        << FD->getName() << FirstParam.getName() << FirstParamTy.getAsString()
-        << Param.getName() << ParamTy.getAsString();
-      Valid = false;
-    }
-  }
-
-  if (Valid) {
-    // If the validation was successful, then populate the fields of
-    // the exportable.
-    if (!(mType = RSExportType::Create(Context, ReturnTy.getTypePtr(),
-                                       NotLegacyKernelArgument))) {
-      // There was an error exporting the type for the reduce kernel.
-      return false;
-    }
-
-    slangAssert(mIns.size() == 2 && FD->param_end() - FD->param_begin() == 2);
-    std::copy(FD->param_begin(), FD->param_end(), mIns.begin());
-  }
-
-  return Valid;
-}
-
-RSExportReduce *RSExportReduce::Create(RSContext *Context,
-                                       const clang::FunctionDecl *FD) {
-  slangAssert(Context && FD);
-  llvm::StringRef Name = FD->getName();
-
-  slangAssert(!Name.empty() && "Function must have a name");
-
-  RSExportReduce *RE = new RSExportReduce(Context, Name);
-
-  if (!RE->validateAndConstructParams(Context, FD)) {
-    // Don't delete RE here - owned by Context.
-    return nullptr;
-  }
-
-  return RE;
-}
-
-bool RSExportReduce::isRSReduceFunc(unsigned int /* targetAPI */,
-                                    const clang::FunctionDecl *FD) {
-  slangAssert(FD);
-  clang::KernelAttr *KernelAttrOrNull = FD->getAttr<clang::KernelAttr>();
-  return KernelAttrOrNull && KernelAttrOrNull->getKernelKind().equals("reduce");
-}
-
-///////////////////////////////////////////////////////////////////////////////////////
-
-const char RSExportReduceNew::KeyReduce[] = "reduce";
-const char RSExportReduceNew::KeyInitializer[] = "initializer";
-const char RSExportReduceNew::KeyAccumulator[] = "accumulator";
-const char RSExportReduceNew::KeyCombiner[] = "combiner";
-const char RSExportReduceNew::KeyOutConverter[] = "outconverter";
-const char RSExportReduceNew::KeyHalter[] = "halter";
-
-bool RSExportReduceNew::matchName(const llvm::StringRef &Candidate) const {
+bool RSExportReduce::matchName(const llvm::StringRef &Candidate) const {
   return
       Candidate.equals(mNameInitializer)  ||
       Candidate.equals(mNameAccumulator)  ||
@@ -203,28 +49,28 @@
       Candidate.equals(mNameHalter);
 }
 
-RSExportReduceNew *RSExportReduceNew::Create(RSContext *Context,
-                                             const clang::SourceLocation Location,
-                                             const llvm::StringRef &NameReduce,
-                                             const llvm::StringRef &NameInitializer,
-                                             const llvm::StringRef &NameAccumulator,
-                                             const llvm::StringRef &NameCombiner,
-                                             const llvm::StringRef &NameOutConverter,
-                                             const llvm::StringRef &NameHalter) {
+RSExportReduce *RSExportReduce::Create(RSContext *Context,
+                                       const clang::SourceLocation Location,
+                                       const llvm::StringRef &NameReduce,
+                                       const llvm::StringRef &NameInitializer,
+                                       const llvm::StringRef &NameAccumulator,
+                                       const llvm::StringRef &NameCombiner,
+                                       const llvm::StringRef &NameOutConverter,
+                                       const llvm::StringRef &NameHalter) {
   slangAssert(Context);
-  RSExportReduceNew *RNE = new RSExportReduceNew(Context,
-                                                 Location,
-                                                 NameReduce,
-                                                 NameInitializer,
-                                                 NameAccumulator,
-                                                 NameCombiner,
-                                                 NameOutConverter,
-                                                 NameHalter);
+  RSExportReduce *RNE = new RSExportReduce(Context,
+                                           Location,
+                                           NameReduce,
+                                           NameInitializer,
+                                           NameAccumulator,
+                                           NameCombiner,
+                                           NameOutConverter,
+                                           NameHalter);
 
   return RNE;
 }
 
-const char *RSExportReduceNew::getKey(FnIdent Kind) {
+const char *RSExportReduce::getKey(FnIdent Kind) {
   switch (Kind) {
     default:
       slangAssert(!"Unknown FnIdent");
@@ -245,7 +91,7 @@
 // This data is needed during analyzeTranslationUnit() but not afterwards.
 // Breaking it out into a struct makes it easy for analyzeTranslationUnit()
 // to call a number of helper functions that all need access to this data.
-struct RSExportReduceNew::StateOfAnalyzeTranslationUnit {
+struct RSExportReduce::StateOfAnalyzeTranslationUnit {
 
   typedef std::function<std::string (const char *Key, const std::string &Name)> DiagnosticDescriptionType;
 
@@ -312,8 +158,8 @@
 };
 
 // does update S.Ok
-clang::FunctionDecl *RSExportReduceNew::lookupFunction(StateOfAnalyzeTranslationUnit &S,
-                                                       const char *Kind, const llvm::StringRef &Name) {
+clang::FunctionDecl *RSExportReduce::lookupFunction(StateOfAnalyzeTranslationUnit &S,
+                                                    const char *Kind, const llvm::StringRef &Name) {
   if (Name.empty())
     return nullptr;
 
@@ -361,7 +207,7 @@
 }
 
 // updates S.Ok; and, depending on Kind, possibly S.FnAccumulatorOk or S.FnOutConverterOk
-void RSExportReduceNew::notOk(StateOfAnalyzeTranslationUnit &S, FnIdent Kind) {
+void RSExportReduce::notOk(StateOfAnalyzeTranslationUnit &S, FnIdent Kind) {
     S.Ok = false;
     if (Kind == FN_IDENT_ACCUMULATOR) {
       S.FnAccumulatorOk = false;
@@ -371,8 +217,8 @@
 }
 
 // updates S.Ok; and, depending on Kind, possibly S.FnAccumulatorOk or S.FnOutConverterOk
-void RSExportReduceNew::checkVoidReturn(StateOfAnalyzeTranslationUnit &S,
-                                        FnIdent Kind, clang::FunctionDecl *Fn) {
+void RSExportReduce::checkVoidReturn(StateOfAnalyzeTranslationUnit &S,
+                                     FnIdent Kind, clang::FunctionDecl *Fn) {
   slangAssert(Fn);
   const clang::QualType ReturnTy = Fn->getReturnType().getCanonicalType();
   if (!ReturnTy->isVoidType()) {
@@ -384,9 +230,9 @@
 }
 
 // updates S.Ok; and, depending on Kind, possibly S.FnAccumulatorOk or S.FnOutConverterOk
-void RSExportReduceNew::checkPointeeConstQualified(StateOfAnalyzeTranslationUnit &S,
-                                                   FnIdent Kind, const llvm::StringRef &Name,
-                                                   const clang::ParmVarDecl *Param, bool ExpectedQualification) {
+void RSExportReduce::checkPointeeConstQualified(StateOfAnalyzeTranslationUnit &S,
+                                                FnIdent Kind, const llvm::StringRef &Name,
+                                                const clang::ParmVarDecl *Param, bool ExpectedQualification) {
   const clang::QualType ParamQType = Param->getType();
   slangAssert(ParamQType->isPointerType());
   const clang::QualType PointeeQType = ParamQType->getPointeeType();
@@ -401,7 +247,7 @@
 }
 
 // Process "void mNameInitializer(compType *accum)"
-void RSExportReduceNew::analyzeInitializer(StateOfAnalyzeTranslationUnit &S) {
+void RSExportReduce::analyzeInitializer(StateOfAnalyzeTranslationUnit &S) {
   if (!S.FnInitializer) // initializer is always optional
     return;
 
@@ -445,7 +291,7 @@
 }
 
 // Process "void mNameAccumulator(compType *accum, in1Type in1, …, inNType inN[, specialarguments])"
-void RSExportReduceNew::analyzeAccumulator(StateOfAnalyzeTranslationUnit &S) {
+void RSExportReduce::analyzeAccumulator(StateOfAnalyzeTranslationUnit &S) {
   slangAssert(S.FnAccumulator);
 
   // Must return void
@@ -584,7 +430,7 @@
 }
 
 // Process "void combinename(compType *accum, const compType *val)"
-void RSExportReduceNew::analyzeCombiner(StateOfAnalyzeTranslationUnit &S) {
+void RSExportReduce::analyzeCombiner(StateOfAnalyzeTranslationUnit &S) {
   if (S.FnCombiner) {
     // Must return void
     checkVoidReturn(S, FN_IDENT_COMBINER, S.FnCombiner);
@@ -676,7 +522,7 @@
 }
 
 // Process "void outconvertname(resultType *result, const compType *accum)"
-void RSExportReduceNew::analyzeOutConverter(StateOfAnalyzeTranslationUnit &S) {
+void RSExportReduce::analyzeOutConverter(StateOfAnalyzeTranslationUnit &S) {
   if (!S.FnOutConverter) // outconverter is always optional
     return;
 
@@ -754,7 +600,7 @@
   }
 }
 
-void RSExportReduceNew::analyzeHalter(StateOfAnalyzeTranslationUnit &S) {
+void RSExportReduce::analyzeHalter(StateOfAnalyzeTranslationUnit &S) {
   if (!S.FnHalter) // halter is always optional
     return;
 
@@ -822,7 +668,7 @@
   checkPointeeConstQualified(S, FN_IDENT_HALTER, mNameHalter, FnHalterParam, true);
 }
 
-void RSExportReduceNew::analyzeResultType(StateOfAnalyzeTranslationUnit &S) {
+void RSExportReduce::analyzeResultType(StateOfAnalyzeTranslationUnit &S) {
   if (!(S.FnAccumulatorOk && S.FnOutConverterOk)) {
     // No idea what the result type is
     slangAssert(!S.Ok);
@@ -896,12 +742,12 @@
   }
 
   if (mResultType)
-    S.RSC.insertExportReduceNewResultType(mResultType);
+    S.RSC.insertExportReduceResultType(mResultType);
   else
     S.Ok = false;
 }
 
-bool RSExportReduceNew::analyzeTranslationUnit() {
+bool RSExportReduce::analyzeTranslationUnit() {
 
   RSContext &RSC = *getRSContext();
   clang::Preprocessor &PP = RSC.getPreprocessor();
diff --git a/slang_rs_export_reduce.h b/slang_rs_export_reduce.h
index 1db0534..491bf19 100644
--- a/slang_rs_export_reduce.h
+++ b/slang_rs_export_reduce.h
@@ -34,54 +34,6 @@
 class RSExportReduce : public RSExportable {
  public:
   typedef llvm::SmallVectorImpl<const clang::ParmVarDecl*> InVec;
-  typedef InVec::const_iterator InIter;
-
- private:
-  // Function name
-  std::string mName;
-  // Input and output type
-  RSExportType *mType;
-  // Inputs
-  llvm::SmallVector<const clang::ParmVarDecl *, 2> mIns;
-
-  RSExportReduce(RSContext *Context, const llvm::StringRef &Name)
-    : RSExportable(Context, RSExportable::EX_REDUCE),
-      mName(Name.data(), Name.size()), mType(nullptr), mIns(2) {
-  }
-
-  RSExportReduce(const RSExportReduce &) = delete;
-  RSExportReduce &operator=(const RSExportReduce &) = delete;
-
-  // Given a reduce kernel declaration, validate the parameters to the
-  // reduce kernel.
-  bool validateAndConstructParams(RSContext *Context,
-                                  const clang::FunctionDecl *FD);
-
- public:
-  static RSExportReduce *Create(RSContext *Context,
-                                const clang::FunctionDecl *FD);
-
-  const std::string &getName() const {
-    return mName;
-  }
-
-  const InVec &getIns() const {
-    return mIns;
-  }
-
-  const RSExportType *getType() const {
-    return mType;
-  }
-
-  static bool isRSReduceFunc(unsigned int targetAPI,
-                             const clang::FunctionDecl *FD);
-
-};  // RSExportReduce
-
-// Base class for reflecting control-side reduce
-class RSExportReduceNew : public RSExportable {
- public:
-  typedef llvm::SmallVectorImpl<const clang::ParmVarDecl*> InVec;
   typedef llvm::SmallVectorImpl<const RSExportType*> InTypeVec;
 
   typedef InVec::const_iterator InIter;
@@ -125,15 +77,15 @@
   // result information
   RSExportType *mResultType;
 
-  RSExportReduceNew(RSContext *Context,
-                    const clang::SourceLocation Location,
-                    const llvm::StringRef &NameReduce,
-                    const llvm::StringRef &NameInitializer,
-                    const llvm::StringRef &NameAccumulator,
-                    const llvm::StringRef &NameCombiner,
-                    const llvm::StringRef &NameOutConverter,
-                    const llvm::StringRef &NameHalter)
-    : RSExportable(Context, RSExportable::EX_REDUCE_NEW),
+  RSExportReduce(RSContext *Context,
+                 const clang::SourceLocation Location,
+                 const llvm::StringRef &NameReduce,
+                 const llvm::StringRef &NameInitializer,
+                 const llvm::StringRef &NameAccumulator,
+                 const llvm::StringRef &NameCombiner,
+                 const llvm::StringRef &NameOutConverter,
+                 const llvm::StringRef &NameHalter)
+    : RSExportable(Context, RSExportable::EX_REDUCE),
       mLocation(Location),
       mNameReduce(NameReduce),
       mNameInitializer(NameInitializer),
@@ -146,8 +98,8 @@
       mResultType(nullptr) {
   }
 
-  RSExportReduceNew(const RSExportReduceNew &) = delete;
-  void operator=(const RSExportReduceNew &) = delete;
+  RSExportReduce(const RSExportReduce &) = delete;
+  void operator=(const RSExportReduce &) = delete;
 
   struct StateOfAnalyzeTranslationUnit;
 
@@ -178,14 +130,14 @@
   static const char KeyOutConverter[];
   static const char KeyHalter[];
 
-  static RSExportReduceNew *Create(RSContext *Context,
-                                   const clang::SourceLocation Location,
-                                   const llvm::StringRef &NameReduce,
-                                   const llvm::StringRef &NameInitializer,
-                                   const llvm::StringRef &NameAccumulator,
-                                   const llvm::StringRef &NameCombiner,
-                                   const llvm::StringRef &NameOutConverter,
-                                   const llvm::StringRef &NameHalter);
+  static RSExportReduce *Create(RSContext *Context,
+                                const clang::SourceLocation Location,
+                                const llvm::StringRef &NameReduce,
+                                const llvm::StringRef &NameInitializer,
+                                const llvm::StringRef &NameAccumulator,
+                                const llvm::StringRef &NameCombiner,
+                                const llvm::StringRef &NameOutConverter,
+                                const llvm::StringRef &NameHalter);
 
   const clang::SourceLocation &getLocation() const { return mLocation; }
 
@@ -209,7 +161,7 @@
   bool matchName(const llvm::StringRef &Candidate) const;
 
   bool analyzeTranslationUnit();
-};  // RSExportReduceNew
+};  // RSExportReduce
 
 }  // namespace slang
 
diff --git a/slang_rs_exportable.h b/slang_rs_exportable.h
index e8613bb..766a388 100644
--- a/slang_rs_exportable.h
+++ b/slang_rs_exportable.h
@@ -28,8 +28,7 @@
     EX_TYPE,
     EX_VAR,
     EX_FOREACH,
-    EX_REDUCE,
-    EX_REDUCE_NEW
+    EX_REDUCE
   };
 
  private:
diff --git a/slang_rs_metadata.h b/slang_rs_metadata.h
index 6d19e9a..b84a8cd 100644
--- a/slang_rs_metadata.h
+++ b/slang_rs_metadata.h
@@ -33,6 +33,6 @@
 
 #define RS_EXPORT_FOREACH_MN "#rs_export_foreach"
 
-#define RS_EXPORT_REDUCE_NEW_MN "#rs_export_reduce"
+#define RS_EXPORT_REDUCE_MN "#rs_export_reduce"
 
 #endif  // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_METADATA_H_  NOLINT
diff --git a/slang_rs_pragma_handler.cpp b/slang_rs_pragma_handler.cpp
index 065cb10..de9ba92 100644
--- a/slang_rs_pragma_handler.cpp
+++ b/slang_rs_pragma_handler.cpp
@@ -145,17 +145,17 @@
 
     // Grab "reduce(name)" ("reduce" is already known to be the first
     // token) and all the "keyword(value)" contributions
-    KeywordValueMapType KeywordValueMap({std::make_pair(RSExportReduceNew::KeyReduce, ""),
-                                         std::make_pair(RSExportReduceNew::KeyInitializer, ""),
-                                         std::make_pair(RSExportReduceNew::KeyAccumulator, ""),
-                                         std::make_pair(RSExportReduceNew::KeyCombiner, ""),
-                                         std::make_pair(RSExportReduceNew::KeyOutConverter, "")});
+    KeywordValueMapType KeywordValueMap({std::make_pair(RSExportReduce::KeyReduce, ""),
+                                         std::make_pair(RSExportReduce::KeyInitializer, ""),
+                                         std::make_pair(RSExportReduce::KeyAccumulator, ""),
+                                         std::make_pair(RSExportReduce::KeyCombiner, ""),
+                                         std::make_pair(RSExportReduce::KeyOutConverter, "")});
     if (mContext->getTargetAPI() >= SLANG_FEATURE_GENERAL_REDUCTION_HALTER_API) {
       // Halter functionality has not been released, nor has its
       // specification been finalized with partners.  We do not have a
       // specification that extends through the full RenderScript
       // software stack, either.
-      KeywordValueMap.insert(std::make_pair(RSExportReduceNew::KeyHalter, ""));
+      KeywordValueMap.insert(std::make_pair(RSExportReduce::KeyHalter, ""));
     }
     while (PragmaToken.is(clang::tok::identifier)) {
       if (!ProcessKeywordAndValue(PP, PragmaToken, KeywordValueMap))
@@ -173,11 +173,11 @@
     }
 
     // Make sure we have an accumulator
-    if (KeywordValueMap[RSExportReduceNew::KeyAccumulator].empty()) {
+    if (KeywordValueMap[RSExportReduce::KeyAccumulator].empty()) {
       PP.Diag(PragmaLocation, PP.getDiagnostics().getCustomDiagID(
                                 clang::DiagnosticsEngine::Error,
                                 "missing '%0' for '#pragma rs %1'"))
-          << RSExportReduceNew::KeyAccumulator << getName();
+          << RSExportReduce::KeyAccumulator << getName();
       return;
     }
 
@@ -185,15 +185,15 @@
     // worried there might be a VERY large number of pragmas, then we
     // could do something more efficient than walking a list to search
     // for duplicates.)
-    for (auto I = mContext->export_reduce_new_begin(),
-              E = mContext->export_reduce_new_end();
+    for (auto I = mContext->export_reduce_begin(),
+              E = mContext->export_reduce_end();
          I != E; ++I) {
-      if ((*I)->getNameReduce() == KeywordValueMap[RSExportReduceNew::KeyReduce]) {
+      if ((*I)->getNameReduce() == KeywordValueMap[RSExportReduce::KeyReduce]) {
         PP.Diag(PragmaLocation, PP.getDiagnostics().getCustomDiagID(
                                   clang::DiagnosticsEngine::Error,
                                   "reduction kernel '%0' declared multiple "
                                   "times (first one is at %1)"))
-            << KeywordValueMap[RSExportReduceNew::KeyReduce]
+            << KeywordValueMap[RSExportReduce::KeyReduce]
             << (*I)->getLocation().printToString(PP.getSourceManager());
         return;
       }
@@ -211,19 +211,19 @@
     }
 
     // Handle backward reference from pragma (see Backend::HandleTopLevelDecl for forward reference).
-    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyInitializer]);
-    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyAccumulator]);
-    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyCombiner]);
-    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyOutConverter]);
-    MarkUsed(PP, KeywordValueMap[RSExportReduceNew::KeyHalter]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduce::KeyInitializer]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduce::KeyAccumulator]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduce::KeyCombiner]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduce::KeyOutConverter]);
+    MarkUsed(PP, KeywordValueMap[RSExportReduce::KeyHalter]);
 
-    mContext->addExportReduceNew(RSExportReduceNew::Create(mContext, PragmaLocation,
-                                                           KeywordValueMap[RSExportReduceNew::KeyReduce],
-                                                           KeywordValueMap[RSExportReduceNew::KeyInitializer],
-                                                           KeywordValueMap[RSExportReduceNew::KeyAccumulator],
-                                                           KeywordValueMap[RSExportReduceNew::KeyCombiner],
-                                                           KeywordValueMap[RSExportReduceNew::KeyOutConverter],
-                                                           KeywordValueMap[RSExportReduceNew::KeyHalter]));
+    mContext->addExportReduce(RSExportReduce::Create(mContext, PragmaLocation,
+                                                     KeywordValueMap[RSExportReduce::KeyReduce],
+                                                     KeywordValueMap[RSExportReduce::KeyInitializer],
+                                                     KeywordValueMap[RSExportReduce::KeyAccumulator],
+                                                     KeywordValueMap[RSExportReduce::KeyCombiner],
+                                                     KeywordValueMap[RSExportReduce::KeyOutConverter],
+                                                     KeywordValueMap[RSExportReduce::KeyHalter]));
   }
 
  private:
@@ -573,7 +573,7 @@
 
   // For #pragma rs reduce
   PP.AddPragmaHandler(
-      "rs", new RSReducePragmaHandler(RSExportReduceNew::KeyReduce, RsContext));
+      "rs", new RSReducePragmaHandler(RSExportReduce::KeyReduce, RsContext));
 
   // For #pragma rs set_reflect_license
   PP.AddPragmaHandler(
diff --git a/slang_rs_reflection.cpp b/slang_rs_reflection.cpp
index 1303470..a203d74 100644
--- a/slang_rs_reflection.cpp
+++ b/slang_rs_reflection.cpp
@@ -67,7 +67,6 @@
 #define RS_EXPORT_FUNC_INDEX_PREFIX "mExportFuncIdx_"
 #define RS_EXPORT_FOREACH_INDEX_PREFIX "mExportForEachIdx_"
 #define RS_EXPORT_REDUCE_INDEX_PREFIX "mExportReduceIdx_"
-#define RS_EXPORT_REDUCE_NEW_INDEX_PREFIX "mExportReduceNewIdx_"
 
 #define RS_EXPORT_VAR_ALLOCATION_PREFIX "mAlloction_"
 #define RS_EXPORT_VAR_DATA_STORAGE_PREFIX "mData_"
@@ -241,7 +240,7 @@
   return "";
 }
 
-std::string GetReduceNewResultTypeName(const RSExportType *ET) {
+std::string GetReduceResultTypeName(const RSExportType *ET) {
   switch (ET->getClass()) {
     case RSExportType::ExportClassConstantArray: {
       const RSExportConstantArrayType *const CAT = static_cast<const RSExportConstantArrayType *>(ET);
@@ -257,8 +256,8 @@
   }
 }
 
-std::string GetReduceNewResultTypeName(const RSExportReduceNew *ER) {
-  return GetReduceNewResultTypeName(ER->getResultType());
+std::string GetReduceResultTypeName(const RSExportReduce *ER) {
+  return GetReduceResultTypeName(ER->getResultType());
 }
 
 } // end anonymous namespace
@@ -395,7 +394,7 @@
                            mRSSourceFileName.c_str())),
       mEmbedBitcodeInJava(EmbedBitcodeInJava), mNextExportVarSlot(0),
       mNextExportFuncSlot(0), mNextExportForEachSlot(0),
-      mNextExportReduceSlot(0), mNextExportReduceNewSlot(0), mLastError(""),
+      mNextExportReduceSlot(0), mLastError(""),
       mGeneratedFileNames(GeneratedFileNames), mFieldIndex(0) {
   slangAssert(mGeneratedFileNames && "Must supply GeneratedFileNames");
   slangAssert(!mPackageName.empty() && mPackageName != "-");
@@ -435,26 +434,20 @@
     }
   }
 
-  // Reflect exported reduce functions
+  // Reflect exported new-style reduce functions
+  for (const RSExportType *ResultType : mRSContext->getReduceResultTypes(
+           // FilterIn
+           exportableReduce,
+
+           // Compare
+           [](const RSExportType *A, const RSExportType *B)
+           { return GetReduceResultTypeName(A) < GetReduceResultTypeName(B); }))
+    genExportReduceResultType(ResultType);
   for (auto I = mRSContext->export_reduce_begin(),
             E = mRSContext->export_reduce_end();
        I != E; ++I)
     genExportReduce(*I);
 
-  // Reflect exported new-style reduce functions
-  for (const RSExportType *ResultType : mRSContext->getReduceNewResultTypes(
-           // FilterIn
-           exportableReduceNew,
-
-           // Compare
-           [](const RSExportType *A, const RSExportType *B)
-           { return GetReduceNewResultTypeName(A) < GetReduceNewResultTypeName(B); }))
-    genExportReduceNewResultType(ResultType);
-  for (auto I = mRSContext->export_reduce_new_begin(),
-            E = mRSContext->export_reduce_new_end();
-       I != E; ++I)
-    genExportReduceNew(*I);
-
   // Reflect exported functions (invokable)
   for (auto I = mRSContext->export_funcs_begin(),
             E = mRSContext->export_funcs_end();
@@ -480,8 +473,7 @@
                 "rs");
 
   const bool haveReduceExportables =
-    mRSContext->export_reduce_begin()     != mRSContext->export_reduce_end() ||
-    mRSContext->export_reduce_new_begin() != mRSContext->export_reduce_new_end();
+    mRSContext->export_reduce_begin() != mRSContext->export_reduce_end();
 
   if (getEmbedBitcodeInJava()) {
     // Call new single argument Java-only constructor
@@ -566,23 +558,16 @@
             E = mRSContext->export_reduce_end();
        I != E; I++) {
     const RSExportReduce *ER = *I;
-    genTypeInstance(ER->getType());
-  }
-
-  for (auto I = mRSContext->export_reduce_new_begin(),
-            E = mRSContext->export_reduce_new_end();
-       I != E; I++) {
-    const RSExportReduceNew *ER = *I;
 
     const RSExportType *RT = ER->getResultType();
     slangAssert(RT != nullptr);
-    if (!exportableReduceNew(RT))
+    if (!exportableReduce(RT))
       continue;
 
     genTypeInstance(RT);
 
-    const RSExportReduceNew::InTypeVec &InTypes = ER->getAccumulatorInTypes();
-    for (RSExportReduceNew::InTypeIter BI = InTypes.begin(), EI = InTypes.end();
+    const RSExportReduce::InTypeVec &InTypes = ER->getAccumulatorInTypes();
+    for (RSExportReduce::InTypeIter BI = InTypes.begin(), EI = InTypes.end();
          BI != EI; BI++) {
       slangAssert(*BI != nullptr);
       genTypeInstance(*BI);
@@ -844,15 +829,6 @@
   mOut.indent() << "}\n";
 }
 
-void RSReflectionJava::genNullOrEmptyArrayCheck(const std::string &ArrayName) {
-  genNullArrayCheck(ArrayName);
-  mOut.indent() << "// Verify that \"" << ArrayName << "\" is non-empty.\n";
-  mOut.indent() << "if (" << ArrayName << ".length == 0) {\n";
-  mOut.indent() << "    throw new RSIllegalArgumentException(\"Array \\\""
-                << ArrayName << "\\\" is zero-length!\");\n";
-  mOut.indent() << "}\n";
-}
-
 void RSReflectionJava::genVectorLengthCompatibilityCheck(const std::string &ArrayName,
                                                          unsigned VecSize) {
   mOut.indent() << "// Verify that the array length is a multiple of the vector size.\n";
@@ -864,19 +840,6 @@
   mOut.indent() << "}\n";
 }
 
-void RSReflectionJava::gen1DCheck(const std::string &Name) {
-  // TODO: Check that t0.getArrayCount() == 0, when / if this API is
-  // un-hidden.
-  mOut.indent() << "Type t0 = " << Name << ".getType();\n";
-  mOut.indent() << "// Verify " << Name << " is 1D\n";
-  mOut.indent() << "if (t0.getY() != 0  ||\n";
-  mOut.indent() << "    t0.hasFaces()   ||\n";
-  mOut.indent() << "    t0.hasMipmaps()) {\n";
-  mOut.indent() << "    throw new RSIllegalArgumentException(\"Parameter "
-                << Name << " is not 1D!\");\n";
-  mOut.indent() << "}\n\n";
-}
-
 void RSReflectionJava::genExportForEach(const RSExportForEach *EF) {
   if (EF->isDummyRoot()) {
     // Skip reflection for dummy root() kernels. Note that we have to
@@ -1059,213 +1022,10 @@
   endFunction();
 }
 
-void RSReflectionJava::genExportReduce(const RSExportReduce *ER) {
-  // Generate the reflected function index.
-  mOut.indent() << "private final static int " << RS_EXPORT_REDUCE_INDEX_PREFIX
-                << ER->getName() << " = " << getNextExportReduceSlot()
-                << ";\n";
-
-  // Two variants of reduce_* entry points get generated:
-  // Array variant:
-  //   ty' reduce_foo(ty[] input)
-  //   ty' reduce_foo(ty[] input, int x1, int x2)
-  // Allocation variant:
-  //   void reduce_foo(Allocation ain, Allocation aout)
-  //   void reduce_foo(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-
-  const RSExportType *Type = ER->getType();
-  const std::string Name = ER->getName();
-
-  genExportReduceArrayVariant(Type, Name);
-  genExportReduceAllocationVariant(Type, Name);
-}
-
-void RSReflectionJava::genExportReduceAllocationVariant(const RSExportType *Type,
-                                                        const std::string &KernelName) {
-  const std::string FuncName = "reduce_" + KernelName;
-
-  // void reduce_foo(Allocation ain, Allocation aout)
-  startFunction(AM_Public, false, "void", FuncName, 2,
-                "Allocation", "ain",
-                "Allocation", "aout");
-  mOut.indent() << FuncName << "(ain, aout, null);\n";
-  endFunction();
-
-  // void reduce_foo(Allocation ain, Allocation aout, Script.LaunchOptions sc)
-  startFunction(AM_Public, false, "void", FuncName, 3,
-                "Allocation", "ain",
-                "Allocation", "aout",
-                "Script.LaunchOptions", "sc");
-
-  // Type checking
-  genTypeCheck(Type, "ain");
-  genTypeCheck(Type, "aout");
-
-  // Check that the input is 1D
-  gen1DCheck("ain");
-
-  // Call backend
-
-  // Script.reduce has the signature
-  //
-  // protected void
-  // reduce(int slot, Allocation ain, Allocation aout, Script.LaunchOptions sc)
-  mOut.indent() << "reduce("
-                << RS_EXPORT_REDUCE_INDEX_PREFIX << KernelName
-                << ", ain, aout, sc);\n";
-
-  endFunction();
-}
-
-void RSReflectionJava::genExportReduceArrayVariant(const RSExportType *Type,
-                                                   const std::string &KernelName) {
-  // Determine if the array variant can be generated. Some type
-  // classes cannot be reflected in Java.
-  auto Class = Type->getClass();
-  if (Class != RSExportType::ExportClassPrimitive &&
-      Class != RSExportType::ExportClassVector) {
-    return;
-  }
-
-  RSReflectionTypeData TypeData;
-  Type->convertToRTD(&TypeData);
-
-  // Check if the type supports reading back from an Allocation and
-  // returning as a first class Java type. If not, the helper cannot
-  // be generated.
-  if (!TypeData.type->java_name || !TypeData.type->java_array_element_name ||
-      (TypeData.vecSize > 1 && !TypeData.type->rs_java_vector_prefix)) {
-    return;
-  }
-
-  const std::string FuncName = "reduce_" + KernelName;
-  const std::string TypeName = GetTypeName(Type);
-  const std::string ReflectedScalarType = TypeData.type->java_name;
-  const std::string ArrayElementType = TypeData.type->java_array_element_name;
-  const std::string ArrayType = ArrayElementType + "[]";
-  const std::string ElementName = Type->getElementName();
-
-  const uint32_t VecSize = TypeData.vecSize;
-
-  std::string InLength = "in.length";
-  // Adjust the length so that it corresponds to the number of
-  // elements in the allocation.
-  if (VecSize > 1) {
-    InLength += " / " + std::to_string(VecSize);
-  }
-
-  // TypeName reduce_foo(ArrayElementType[] in)
-  startFunction(AM_Public, false, TypeName.c_str(), FuncName, 1,
-                ArrayType.c_str(), "in");
-  genNullOrEmptyArrayCheck("in");
-  if (VecSize > 1) {
-    genVectorLengthCompatibilityCheck("in", VecSize);
-  }
-  mOut.indent() << "return " << FuncName << "(in, 0, "
-                << InLength << ");\n";
-  endFunction();
-
-  // TypeName reduce_foo(ArrayElementType[] in, int x1, int x2)
-
-  startFunction(AM_Public, false, TypeName.c_str(), FuncName, 3,
-                ArrayType.c_str(), "in",
-                "int", "x1",
-                "int", "x2");
-
-  genNullOrEmptyArrayCheck("in");
-  if (VecSize > 1) {
-    genVectorLengthCompatibilityCheck("in", VecSize);
-  }
-  // Check that 0 <= x1 and x1 < x2 and x2 <= InLength
-  mOut.indent() << "// Bounds check passed x1 and x2\n";
-  mOut.indent() << "if (x1 < 0 || x1 >= x2 || x2 > " << InLength << ") {\n";
-  mOut.indent() << "    throw new RSRuntimeException("
-                << "\"Input bounds are invalid!\");\n";
-  mOut.indent() << "}\n";
-
-  // Create a temporary input allocation.
-  mOut.indent() << "Allocation ain = Allocation.createSized("
-                << SAVED_RS_REFERENCE << ", "
-                << RS_ELEM_PREFIX << ElementName << ", "
-                << "x2 - x1);\n";
-  mOut.indent() << "ain.setAutoPadding(true);\n";
-  mOut.indent() << "ain.copy1DRangeFrom(x1, x2 - x1, in);\n";
-
-  // Create a temporary output allocation.
-  mOut.indent() << "Allocation aout = Allocation.createSized("
-                << SAVED_RS_REFERENCE << ", "
-                << RS_ELEM_PREFIX << ElementName << ", "
-                << "1);\n";
-  mOut.indent() << "aout.setAutoPadding(true);\n";
-
-  mOut.indent() << FuncName << "(ain, aout, null);\n";
-
-  if (VecSize > 1) {
-    // An allocation with vector elements is represented as an array
-    // of primitives, so we have to extract the output from the
-    // element array and rebuild the vector.
-    //
-    // E.g. for int2
-    //
-    // Allocation outArray = new int[2];
-    // aout.copyTo(outArray);
-    // int elem0 = outArray[0];
-    // int elem1 = outArray[1];
-    // return new Int2(elem0, elem1);
-
-    mOut.indent() << ArrayType << " outArray = new "
-                  << ArrayElementType << "[" << VecSize << "];\n";
-
-    mOut.indent() << "aout.copy1DRangeTo(0, 1, outArray);\n";
-
-    for (unsigned Elem = 0; Elem < VecSize; ++Elem) {
-      mOut.indent() << ReflectedScalarType << " elem" << Elem << " = ";
-      std::string Index = "outArray[" + std::to_string(Elem) + "]";
-
-      if (ReflectedScalarType == ArrayElementType) {
-        mOut << Index << ";\n";
-      } else {
-        mOut << ZeroExtendValue(Index, ArrayElementType, ReflectedScalarType) << ";\n";
-      }
-    }
-
-    mOut.indent() << "return new " << TypeName << "(";
-    for (unsigned Elem = 0; Elem < VecSize; ++Elem) {
-      if (Elem > 0) mOut << ", ";
-      mOut << "elem" << Elem;
-    }
-    mOut << ");\n";
-  } else {
-    // Scalar handling.
-    //
-    // E.g. for int
-    // Allocation outArray = new int[1];
-    // aout.copyTo(outArray);
-    // return outArray[0];
-    mOut.indent() << ArrayType << " outArray = new " << ArrayElementType
-                  << "[1];\n";
-    mOut.indent() << "aout.copyTo(outArray);\n";
-
-    if (ReflectedScalarType == "boolean") {
-      mOut.indent() << "return outArray[0] != 0;\n";
-    } else if (ReflectedScalarType == ArrayElementType) {
-      mOut.indent() << "return outArray[0];\n";
-    } else {
-      mOut.indent() << "return "
-                    << ZeroExtendValue("outArray[0]",
-                                       ArrayElementType,
-                                       ReflectedScalarType)
-                    << ";\n";
-    }
-  }
-
-  endFunction();
-}
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Reductions with certain legal result types can only be reflected for NDK, not for Java.
-bool RSReflectionJava::exportableReduceNew(const RSExportType *ResultType) {
+bool RSReflectionJava::exportableReduce(const RSExportType *ResultType) {
   const RSExportType *CheckType = ResultType;
   if (ResultType->getClass() == RSExportType::ExportClassConstantArray)
     CheckType = static_cast<const RSExportConstantArrayType *>(ResultType)->getElementType();
@@ -1289,9 +1049,9 @@
 //   MappingComment      = whether or not InputMappingComment should contain type
 //   ER                  = description of the reduction
 //   InIdx               = which input (numbered from zero)
-void getReduceNewInputStrings(std::string &InputParamName, std::string &InputMappingComment,
-                              const std::string &NamePrefix, MappingComment Mapping,
-                              const RSExportReduceNew *ER, size_t InIdx) {
+void getReduceInputStrings(std::string &InputParamName, std::string &InputMappingComment,
+                           const std::string &NamePrefix, MappingComment Mapping,
+                           const RSExportReduce *ER, size_t InIdx) {
   InputParamName = NamePrefix + std::to_string(InIdx+1);
   std::string TypeString;
   if (Mapping == MappingCommentWithCType) {
@@ -1315,13 +1075,13 @@
 
 } // end anonymous namespace
 
-void RSReflectionJava::genExportReduceNew(const RSExportReduceNew *ER) {
-  if (!exportableReduceNew(ER->getResultType()))
+void RSReflectionJava::genExportReduce(const RSExportReduce *ER) {
+  if (!exportableReduce(ER->getResultType()))
     return;
 
   // Generate the reflected function index.
-  mOut.indent() << "private final static int " << RS_EXPORT_REDUCE_NEW_INDEX_PREFIX
-                << ER->getNameReduce() << " = " << getNextExportReduceNewSlot()
+  mOut.indent() << "private final static int " << RS_EXPORT_REDUCE_INDEX_PREFIX
+                << ER->getNameReduce() << " = " << getNextExportReduceSlot()
                 << ";\n";
 
   /****** remember resultSvType generation **********************************************************/
@@ -1333,11 +1093,11 @@
   //   result_<resultSvType> reduce_<name>(Allocation in1, ..., Allocation inN)
   //   result_<resultSvType> reduce_<name>(Allocation in1, ..., Allocation inN, Script.LaunchOptions sc)
 
-  genExportReduceNewArrayVariant(ER);
-  genExportReduceNewAllocationVariant(ER);
+  genExportReduceArrayVariant(ER);
+  genExportReduceAllocationVariant(ER);
 }
 
-void RSReflectionJava::genExportReduceNewArrayVariant(const RSExportReduceNew *ER) {
+void RSReflectionJava::genExportReduceArrayVariant(const RSExportReduce *ER) {
   // Analysis of result type.  Returns early if result type is not
   // suitable for array method reflection.
   const RSExportType *const ResultType = ER->getResultType();
@@ -1369,7 +1129,7 @@
     slangAssert(false);
     return;
   }
-  const std::string ResultTypeName = GetReduceNewResultTypeName(ER);
+  const std::string ResultTypeName = GetReduceResultTypeName(ER);
 
   // Analysis of inputs.  Returns early if some input type is not
   // suitable for array method reflection.
@@ -1414,7 +1174,7 @@
     }
 
     std::string InputParamName, InputComment;
-    getReduceNewInputStrings(InputParamName, InputComment, "in", MappingCommentWithoutType, ER, InIdx);
+    getReduceInputStrings(InputParamName, InputComment, "in", MappingCommentWithoutType, ER, InIdx);
     if (InTypeData.vecSize > 1)
       InputComment += (", flattened " + std::to_string(InTypeData.vecSize) + "-vectors");
     InComments.push_back(InputComment);
@@ -1490,7 +1250,7 @@
   endFunction();
 }
 
-void RSReflectionJava::genExportReduceNewAllocationVariant(const RSExportReduceNew *ER) {
+void RSReflectionJava::genExportReduceAllocationVariant(const RSExportReduce *ER) {
   const auto &Ins = ER->getAccumulatorIns();
   const auto &InTypes = ER->getAccumulatorInTypes();
   const RSExportType *ResultType = ER->getResultType();
@@ -1499,13 +1259,13 @@
   ArgTy Args;
   for (size_t InIdx = 0, InEnd = Ins.size(); InIdx < InEnd; ++InIdx) {
     std::string InputParamName, InputComment;
-    getReduceNewInputStrings(InputParamName, InputComment, "ain", MappingCommentWithCType, ER, InIdx);
+    getReduceInputStrings(InputParamName, InputComment, "ain", MappingCommentWithCType, ER, InIdx);
     InComments.push_back(InputComment);
     Args.push_back(std::make_pair("Allocation", InputParamName));
   }
 
   const std::string MethodName = "reduce_" + ER->getNameReduce();
-  const std::string ResultTypeName = GetReduceNewResultTypeName(ER);
+  const std::string ResultTypeName = GetReduceResultTypeName(ER);
 
   // result_<resultSvType> reduce_<name>(Allocation in1, ..., Allocation inN)
 
@@ -1554,7 +1314,7 @@
                 << OutputAllocLength << ");\n";
   mOut.indent() << OutputAllocName << ".setAutoPadding(true);\n";
   // Call the underlying reduce entry point
-  mOut.indent() << "reduce(" << RS_EXPORT_REDUCE_NEW_INDEX_PREFIX << ER->getNameReduce()
+  mOut.indent() << "reduce(" << RS_EXPORT_REDUCE_INDEX_PREFIX << ER->getNameReduce()
                 << ", new Allocation[]{" << In0Name;
   for (size_t InIdx = 1, InEnd = Ins.size(); InIdx < InEnd; ++InIdx)
     mOut << ", " << Args[InIdx].second;
@@ -1581,10 +1341,10 @@
 // ReflectedScalarTypeName = type of mapped value
 // InVal                   = input value that must be mapped
 //
-std::string genReduceNewResultMapping(MapFromAllocation MFA,
-                                      const std::string &ArrayElementTypeName,
-                                      const std::string &ReflectedScalarTypeName,
-                                      const char *InVal) {
+std::string genReduceResultMapping(MapFromAllocation MFA,
+                                   const std::string &ArrayElementTypeName,
+                                   const std::string &ReflectedScalarTypeName,
+                                   const char *InVal) {
   switch (MFA) {
     default:
       slangAssert(!"Unknown MapFromAllocation");
@@ -1611,12 +1371,12 @@
 // InArray                 = input array containing vector elements
 // InIdx                   = index of first vector element within InArray (or nullptr, if 0)
 //
-std::string genReduceNewResultVectorMapping(MapFromAllocation MFA,
-                                            const std::string &ArrayElementTypeName,
-                                            const std::string &ReflectedScalarTypeName,
-                                            const std::string &VectorTypeName,
-                                            unsigned VectorElementCount,
-                                            const char *InArray, const char *InIdx = nullptr) {
+std::string genReduceResultVectorMapping(MapFromAllocation MFA,
+                                         const std::string &ArrayElementTypeName,
+                                         const std::string &ReflectedScalarTypeName,
+                                         const std::string &VectorTypeName,
+                                         unsigned VectorElementCount,
+                                         const char *InArray, const char *InIdx = nullptr) {
   std::string result = "new " + VectorTypeName + "(";
   for (unsigned VectorElementIdx = 0; VectorElementIdx < VectorElementCount; ++VectorElementIdx) {
     if (VectorElementIdx)
@@ -1627,25 +1387,25 @@
       ArrayElementName += std::string(InIdx) + "+";
     ArrayElementName += std::to_string(VectorElementIdx) + "]";
 
-    result += genReduceNewResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
-                                        ArrayElementName.c_str());
+    result += genReduceResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
+                                     ArrayElementName.c_str());
   }
   result += ")";
   return result;
 }
 
-void genReduceNewResultRangeCheck(GeneratedFile &Out, const char *InVal) {
+void genReduceResultRangeCheck(GeneratedFile &Out, const char *InVal) {
   Out.indent() << "if (" << InVal << " < 0)\n";
   Out.indent() << "    throw new RSRuntimeException(\"Result is not representible in Java\");\n";
 }
 
 } // end anonymous namespace
 
-void RSReflectionJava::genExportReduceNewResultType(const RSExportType *ResultType) {
-  if (!exportableReduceNew(ResultType))
+void RSReflectionJava::genExportReduceResultType(const RSExportType *ResultType) {
+  if (!exportableReduce(ResultType))
     return;
 
-  const std::string ClassName = GetReduceNewResultTypeName(ResultType);
+  const std::string ClassName = GetReduceResultTypeName(ResultType);
   const std::string GetMethodReturnTypeName = GetTypeName(ResultType);
   mOut.indent() << "// To obtain the result, invoke get(), which blocks\n";
   mOut.indent() << "// until the asynchronously-launched operation has completed.\n";
@@ -1685,10 +1445,10 @@
     if (TypeData.arraySize == 0) { // result type is non-array non-vector
       // mResult = outArray[0]; // but there are several special cases
       if (MFA == MapFromAllocationPositive)
-        genReduceNewResultRangeCheck(mOut, "outArray[0]");
+        genReduceResultRangeCheck(mOut, "outArray[0]");
       mOut.indent() << "mResult = "
-                    << genReduceNewResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
-                                                 "outArray[0]")
+                    << genReduceResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
+                                              "outArray[0]")
                     << ";\n";
     } else { // result type is array of non-vector
       if (MFA == MapFromAllocationTrivial) {
@@ -1707,10 +1467,10 @@
         mOut.indent() << "for (int Idx = 0; Idx < " << TypeData.arraySize << "; ++Idx)";
         mOut.startBlock();
         if (MFA == MapFromAllocationPositive) {
-          genReduceNewResultRangeCheck(mOut, "outArray[Idx]");
+          genReduceResultRangeCheck(mOut, "outArray[Idx]");
         } else {
           mOut.indent() << "result[Idx] = "
-                        << genReduceNewResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
+                        << genReduceResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
                                                      "outArray[Idx]")
                         << ";\n";
         }
@@ -1729,16 +1489,16 @@
     if (MFA == MapFromAllocationPositive) {
       mOut.indent() << "for (int Idx = 0; Idx < " << OutArrayElementCount << "; ++Idx)";
       mOut.startBlock();
-      genReduceNewResultRangeCheck(mOut, "outArray[Idx]");
+      genReduceResultRangeCheck(mOut, "outArray[Idx]");
       mOut.endBlock();
     }
     if (TypeData.arraySize == 0) { // result type is vector
       // mResult = new <ResultType>(outArray[0], outArray[1] ...); // but there are several special cases
       mOut.indent() << "mResult = "
-                    << genReduceNewResultVectorMapping(MFA,
-                                                       ArrayElementTypeName, ReflectedScalarTypeName,
-                                                       GetTypeName(ResultType), VectorElementCount,
-                                                       "outArray")
+                    << genReduceResultVectorMapping(MFA,
+                                                    ArrayElementTypeName, ReflectedScalarTypeName,
+                                                    GetTypeName(ResultType), VectorElementCount,
+                                                    "outArray")
                     << ";\n";
     } else { // result type is array of vector
       // <ResultType> result = new <UnbracketedResultType>[<ArrayElementCount>];
@@ -1752,10 +1512,10 @@
       mOut.indent() << "for (int Idx = 0; Idx < " << TypeData.arraySize << "; ++Idx)";
       mOut.startBlock();
       mOut.indent() << "result[Idx] = "
-                    << genReduceNewResultVectorMapping(MFA,
-                                                       ArrayElementTypeName, ReflectedScalarTypeName,
-                                                       UnbracketedResultTypeName, VectorElementCount,
-                                                       "outArray", (std::to_string(VectorElementCount) + "*Idx").c_str())
+                    << genReduceResultVectorMapping(MFA,
+                                                    ArrayElementTypeName, ReflectedScalarTypeName,
+                                                    UnbracketedResultTypeName, VectorElementCount,
+                                                    "outArray", (std::to_string(VectorElementCount) + "*Idx").c_str())
                     << ";\n";
       mOut.endBlock();
       mOut.indent() << "mResult = result;\n";
diff --git a/slang_rs_reflection.h b/slang_rs_reflection.h
index 9a5078c..c95e203 100644
--- a/slang_rs_reflection.h
+++ b/slang_rs_reflection.h
@@ -82,7 +82,6 @@
   int mNextExportFuncSlot;
   int mNextExportForEachSlot;
   int mNextExportReduceSlot;
-  int mNextExportReduceNewSlot;
 
   GeneratedFile mOut;
 
@@ -104,7 +103,6 @@
     mNextExportFuncSlot = 0;
     mNextExportForEachSlot = 0;
     mNextExportReduceSlot = 0;
-    mNextExportReduceNewSlot = 0;
   }
 
 public:
@@ -132,7 +130,6 @@
   inline int getNextExportFuncSlot() { return mNextExportFuncSlot++; }
   inline int getNextExportForEachSlot() { return mNextExportForEachSlot++; }
   inline int getNextExportReduceSlot() { return mNextExportReduceSlot++; }
-  inline int getNextExportReduceNewSlot() { return mNextExportReduceNewSlot++; }
 
   bool startClass(AccessModifier AM, bool IsStatic,
                   const std::string &ClassName, const char *SuperClassName,
@@ -175,7 +172,7 @@
   inline void clearFieldIndexMap() { mFieldIndexMap.clear(); }
 
 private:
-  static bool exportableReduceNew(const RSExportType *ResultType);
+  static bool exportableReduce(const RSExportType *ResultType);
 
   bool genScriptClass(const std::string &ClassName, std::string &ErrorMsg);
   void genScriptClassConstructor();
@@ -206,15 +203,9 @@
   void genExportForEach(const RSExportForEach *EF);
 
   void genExportReduce(const RSExportReduce *ER);
-  void genExportReduceAllocationVariant(const RSExportType *Type,
-                                        const std::string &KernelName);
-  void genExportReduceArrayVariant(const RSExportType *Type,
-                                   const std::string &KernelName);
-
-  void genExportReduceNew(const RSExportReduceNew *ER);
-  void genExportReduceNewAllocationVariant(const RSExportReduceNew *ER);
-  void genExportReduceNewArrayVariant(const RSExportReduceNew *ER);
-  void genExportReduceNewResultType(const RSExportType *ResultType);
+  void genExportReduceAllocationVariant(const RSExportReduce *ER);
+  void genExportReduceArrayVariant(const RSExportReduce *ER);
+  void genExportReduceResultType(const RSExportType *ResultType);
 
   void genTypeCheck(const RSExportType *ET, const char *VarName);
 
@@ -255,8 +246,6 @@
   void genPairwiseDimCheck(std::string name0, std::string name1);
   void genVectorLengthCompatibilityCheck(const std::string &ArrayName, unsigned VecSize);
   void genNullArrayCheck(const std::string &ArrayName);
-  void genNullOrEmptyArrayCheck(const std::string &ArrayName);
-  void gen1DCheck(const std::string &Name);
 
 public:
   RSReflectionJava(const RSContext *Context,
diff --git a/slang_rs_reflection_cpp.cpp b/slang_rs_reflection_cpp.cpp
index 7bf9e3b..60fb6fa 100644
--- a/slang_rs_reflection_cpp.cpp
+++ b/slang_rs_reflection_cpp.cpp
@@ -31,7 +31,6 @@
 #include "slang_rs_export_var.h"
 #include "slang_rs_export_foreach.h"
 #include "slang_rs_export_func.h"
-#include "slang_rs_export_reduce.h"
 #include "slang_rs_reflect_utils.h"
 #include "slang_version.h"
 
@@ -45,7 +44,6 @@
 const char kRsElemPrefix[] = "__rs_elem_";
 // The name of the Allocation type that is reflected in C++
 const char kAllocationSp[] = "android::RSC::sp<android::RSC::Allocation>";
-const char kConstRsScriptCall[] = "const RsScriptCall";
 
 static const char *GetMatrixTypeName(const RSExportMatrixType *EMT) {
   static const char *MatrixTypeCNameMap[] = {
@@ -118,23 +116,13 @@
   return "";
 }
 
-static bool canExportReduceArrayVariant(const RSExportType *Type) {
-  // FIXME: No half types available for C++ reflection yet
-  if (Type->getElementName().find("F16") == 0) {
-    return false;
-  }
-  return Type->getClass() == RSExportType::ExportClassPrimitive ||
-    Type->getClass() == RSExportType::ExportClassVector;
-}
-
 RSReflectionCpp::RSReflectionCpp(const RSContext *Context,
                                  const string &OutputDirectory,
                                  const string &RSSourceFileName,
                                  const string &BitCodeFileName)
     : mRSContext(Context), mRSSourceFilePath(RSSourceFileName),
       mBitCodeFilePath(BitCodeFileName), mOutputDirectory(OutputDirectory),
-      mNextExportVarSlot(0), mNextExportFuncSlot(0), mNextExportForEachSlot(0),
-      mNextExportReduceSlot(0) {
+      mNextExportVarSlot(0), mNextExportFuncSlot(0), mNextExportForEachSlot(0) {
   mCleanedRSFileName = RootNameFromRSFileName(mRSSourceFilePath);
   mClassName = "ScriptC_" + mCleanedRSFileName;
 }
@@ -174,7 +162,6 @@
 
   genFieldsToStoreExportVariableValues();
   genTypeInstancesUsedInForEach();
-  genTypeInstancesUsedInReduce();
   genFieldsForAllocationTypeVerification();
 
   mOut.decreaseIndent();
@@ -187,7 +174,6 @@
 
   genExportVariablesGetterAndSetter();
   genForEachDeclarations();
-  genReduceDeclarations();
   genExportFunctionDeclarations();
 
   mOut.endBlock(true);
@@ -216,15 +202,6 @@
   }
 }
 
-// Ensure that the type of the reduce kernel is reflected.
-void RSReflectionCpp::genTypeInstancesUsedInReduce() {
-  for (auto I = mRSContext->export_reduce_begin(),
-            E = mRSContext->export_reduce_end();
-       I != E; ++I) {
-    genTypeInstance((*I)->getType());
-  }
-}
-
 void RSReflectionCpp::genFieldsForAllocationTypeVerification() {
   bool CommentAdded = false;
   for (std::set<std::string>::iterator I = mTypesToCheck.begin(),
@@ -317,21 +294,6 @@
   }
 }
 
-void RSReflectionCpp::genReduceDeclarations() {
-  bool CommentAdded = false;
-  for (auto I = mRSContext->export_reduce_begin(),
-            E = mRSContext->export_reduce_end(); I != E; I++) {
-    if (!CommentAdded) {
-      mOut.comment("For each reduce kernel of the script, there is an entry "
-                   "point to call the reduce kernel.");
-      CommentAdded = true;
-    }
-
-    makeReduceSignatureAllocationVariant(false, *I);
-    makeReduceSignatureArrayVariant(false, *I);
-  }
-}
-
 void RSReflectionCpp::genExportFunctionDeclarations() {
   for (RSContext::const_export_func_iterator
            I = mRSContext->export_funcs_begin(),
@@ -426,103 +388,6 @@
   }
 }
 
-// reduce_* implementation
-void RSReflectionCpp::genExportReduceBodies() {
-  for (auto I = mRSContext->export_reduce_begin(),
-            E = mRSContext->export_reduce_end();
-       I != E; ++I) {
-    const RSExportReduce &Reduce = **I;
-    const RSExportType *Type = Reduce.getType();
-
-    // Allocation variant
-    //
-    // void reduce_foo(sp<Allocation> ain, sp<Allocation> aout,
-    //                 const RsScriptCall *sc);
-    makeReduceSignatureAllocationVariant(true, &Reduce);
-    mOut.startBlock();
-
-    // Type check
-    genTypeCheck(Type, "ain");
-    genTypeCheck(Type, "aout");
-
-    // Dimension check
-    gen1DCheck("ain");
-
-    const uint32_t Slot = getNextExportReduceSlot();
-
-    // Call into RenderScript.
-    mOut.indent() << "reduce(" << Slot << ", "
-                  << "ain, aout, sc);\n";
-    mOut.endBlock();
-
-    if (!canExportReduceArrayVariant(Type)) {
-      continue;
-    }
-
-    // Array variant
-    //
-    // Ty reduce_foo(const ElemTy[] in, uint32_t x1, uint32_t x2, uint32_t inLen);
-    // "Ty" could be different from "ElemTy" in the case of vectors.
-    makeReduceSignatureArrayVariant(true, &Reduce);
-    mOut.startBlock();
-
-    const std::string ReturnType = GetTypeName(Type);
-    const std::string DefaultReturnValue = ReturnType + "()";
-
-    genNullOrEmptyArrayCheck("in", "inLen", DefaultReturnValue);
-
-    RSReflectionTypeData TypeData;
-    Type->convertToRTD(&TypeData);
-    const uint32_t VecSize = TypeData.vecSize;
-    std::string InLength = "inLen";
-    // Adjust the length so that it corresponds to the number of elements in the allocation.
-    if (VecSize > 1) {
-      InLength += " / " + std::to_string(VecSize);
-    }
-    genVectorLengthCompatibilityCheck("inLen", VecSize, DefaultReturnValue);
-
-    mOut.indent() << "if (x1 >= x2 || x2 > " << InLength << ")";
-    mOut.startBlock();
-    mOut.indent() << "mRS->throwError(RS_ERROR_RUNTIME_ERROR, "
-                  << "\"Input bounds are invalid\");\n";
-    mOut.indent() << "return " << DefaultReturnValue << ";\n";
-    mOut.endBlock();
-
-    mOut.indent() << kAllocationSp
-                  << " ain = android::RSC::Allocation::createSized(mRS, "
-                  << kRsElemPrefix << Type->getElementName() << ", "
-                  << "x2 - x1);\n";
-
-    mOut.indent() << "ain->setAutoPadding(true);\n";
-
-    mOut.indent() << kAllocationSp
-                  << " aout = android::RSC::Allocation::createSized(mRS, "
-                  << kRsElemPrefix << Type->getElementName() << ", 1);\n";
-
-    mOut.indent() << "aout->setAutoPadding(true);\n";
-
-    const std::string ArrayElementType = TypeData.type->c_name;
-
-    std::string StartOffset = "x1";
-    if (VecSize > 1) {
-      StartOffset += " * " + std::to_string(VecSize);
-    }
-    mOut.indent() << "ain->copy1DRangeFrom(0, x2 - x1, &in[" << StartOffset << "]);\n";
-    mOut.indent() << "reduce_" << Reduce.getName() << "(ain, aout);\n";
-    mOut.indent() << ArrayElementType << " outArray[" << VecSize << "];\n";
-
-    mOut.indent() << "aout->copy1DRangeTo(0, 1, &outArray[0]);\n";
-
-    mOut.indent() << "return " << ReturnType << "(";
-    for (uint32_t VecElem = 0; VecElem < VecSize; ++VecElem) {
-      if (VecElem > 0) mOut << ", ";
-      mOut << "outArray[" << VecElem << "]";
-    }
-    mOut << ");\n";
-    mOut.endBlock();
-  }
-}
-
 // invoke_* implementation
 void RSReflectionCpp::genExportFunctionBodies() {
   uint32_t slot = 0;
@@ -629,7 +494,6 @@
 
   // Function bodies
   genExportForEachBodies();
-  genExportReduceBodies();
   genExportFunctionBodies();
 
   mOut.closeFile();
@@ -864,131 +728,6 @@
   }
 }
 
-void RSReflectionCpp::makeReduceSignatureAllocationVariant(bool IsDefinition,
-                                                           const RSExportReduce *ER) {
-  // void reduce_foo(sp<Allocation> ain, sp<Allocation> aout,
-  //                 const RsScriptCall *sc = nullptr);
-  std::string FunctionStart = "void ";
-  if (IsDefinition) {
-    FunctionStart += mClassName +  "::";
-  }
-  FunctionStart += "reduce_" + ER->getName() + "(";
-
-  ArgumentList Arguments{
-    Argument(kAllocationSp, "ain"),
-    Argument(kAllocationSp, "aout"),
-    Argument(kConstRsScriptCall, "*sc", IsDefinition ? "" : "nullptr")
-  };
-
-  mOut.indent() << FunctionStart;
-
-  genArguments(Arguments, FunctionStart.length());
-
-  if (IsDefinition) {
-    mOut << ")";
-  } else {
-    mOut << ");\n\n";
-  }
-}
-
-void RSReflectionCpp::makeReduceSignatureArrayVariant(bool IsDefinition,
-                                                      const RSExportReduce *ER) {
-  // Ty reduce_foo(const ElemTy[] in, uint32_t x1, uint32_t x2, size_t inLen);
-  // "Ty" could be different from "ElemTy" in the case of vectors.
-
-  const RSExportType *Type = ER->getType();
-  if (!canExportReduceArrayVariant(Type)) {
-      return;
-  }
-
-  RSReflectionTypeData TypeData;
-  Type->convertToRTD(&TypeData);
-
-  const std::string ReturnType = GetTypeName(Type);
-  std::string FunctionStart = ReturnType + " ";
-  if (IsDefinition) {
-    FunctionStart += mClassName +  "::";
-  }
-  FunctionStart += "reduce_" + ER->getName() + "(";
-
-  const std::string ArrayElementType = TypeData.type->c_name;
-
-  ArgumentList Arguments{
-    Argument("const " + ArrayElementType, "in[]"),
-    Argument("uint32_t", "x1"),
-    Argument("uint32_t", "x2"),
-    Argument("size_t", "inLen")
-  };
-
-  mOut.indent() << FunctionStart;
-  genArguments(Arguments, FunctionStart.size());
-
-  if (IsDefinition) {
-    mOut << ")";
-  } else {
-    mOut << ");\n\n";
-  }
-
-  if (!IsDefinition) {
-    // We reflect three more variants in the header. First, there is
-    //
-    //   Ty reduce_foo(const ElemTy[] in, size_t inLen);
-    //
-    // Note the inLen is the number of primitive elements in the array, as opposed to the
-    // bounds whose units are allocation elements. The other variants use templates to infer
-    // the array length statically:
-    //
-    //   template<size_t inLen> Ty reduce_foo(const ElemTy (&in)[inLen]);
-    //   template<size_t inLen> Ty reduce_foo(const ElemTy (&in)[inLen], uint32_t x1, uint32_t x2);
-
-    // Generate inLen variant
-    const uint32_t VecSize = TypeData.vecSize;
-    std::string X2 = "inLen";
-
-    const std::string FunctionName = ER->getName();
-
-    auto ForwardReduce = [this, &FunctionName](const std::string &x1,
-                                               const std::string &x2,
-                                               const std::string &inLen) {
-      this->mOut.indent() << "    return reduce_" << FunctionName << "(in, "
-                          << x1 << ", " << x2 << ", " << inLen << ");\n";
-      this->mOut.indent() << "}\n\n";
-    };
-
-    const std::string DefaultValue = ReturnType + "()";
-
-    ArgumentList InLenVariantArguments{
-      Argument("const " + ArrayElementType, "in[]"), Argument("size_t", "inLen")
-    };
-    mOut.indent() << FunctionStart;
-    genArguments(InLenVariantArguments, FunctionStart.size());
-    mOut << ") {\n";
-    if (VecSize > 1) {
-      genVectorLengthCompatibilityCheck("inLen", VecSize, DefaultValue, 2);
-      X2 += " / " + std::to_string(VecSize);
-    }
-    ForwardReduce("0", X2, "inLen");
-
-    // Generate template variants
-    ArgumentList TemplateVariantArguments{
-      Argument("const " + ArrayElementType, "(&in)[inLen]")
-    };
-
-    mOut.indent() << "template<size_t inLen>\n";
-    mOut.indent() << FunctionStart;
-    genArguments(TemplateVariantArguments, FunctionStart.size());
-    mOut << ") {\n        return reduce_" << FunctionName << "(in, inLen);\n    }\n\n";
-
-    TemplateVariantArguments.push_back(Argument("uint32_t", "x1"));
-    TemplateVariantArguments.push_back(Argument("uint32_t", "x2"));
-    mOut.indent() << "template<size_t inLen>\n";
-    mOut.indent() << FunctionStart;
-    genArguments(TemplateVariantArguments, FunctionStart.size());
-    mOut << ") {\n";
-    ForwardReduce("x1", "x2", "inLen");
-  }
-}
-
 void RSReflectionCpp::genArguments(const ArgumentList &Arguments, int Offset) {
   bool FirstArg = true;
 
@@ -1146,60 +885,6 @@
   }
 }
 
-// Ensure that the input is 1 dimensional.
-void RSReflectionCpp::gen1DCheck(const std::string &VarName) {
-  mOut.indent() << "// check that " << VarName << " is 1d\n";
-  mOut.indent() << "sp<const Type> t0 = " << VarName << "->getType();\n";
-  mOut.indent() << "if (t0->getY() != 0 ||\n";
-  mOut.indent() << "    t0->hasFaces()  ||\n";
-  mOut.indent() << "    t0->hasMipmaps())";
-  mOut.startBlock();
-  mOut.indent() << "mRS->throwError(RS_ERROR_INVALID_PARAMETER, "
-                << "\"" << VarName << " is not 1D!\");\n";
-  mOut.indent() << "return;\n";
-  mOut.endBlock();
-}
-
-// Generates code to ensure that the supplied array length is a multiple of the vector size.
-void RSReflectionCpp::genVectorLengthCompatibilityCheck(const std::string &Length,
-                                                        unsigned VecSize,
-                                                        const std::string &ValueToReturn,
-                                                        unsigned IndentLevels) {
-  auto Indenter = [this, IndentLevels]() -> std::ofstream& {
-    GeneratedFile &Out = this->mOut;
-    for (unsigned Level = 0; Level < IndentLevels; ++Level) {
-      Out.indent();
-    }
-    return Out;
-  };
-
-  Indenter() << "// Verify that the array length is a multiple of the vector size.\n";
-  Indenter() << "if (" << Length << " % " << std::to_string(VecSize) << " != 0) {\n";
-  Indenter() << "    mRS->throwError(RS_ERROR_INVALID_PARAMETER, "
-             << "\"Input array length is not a multiple of "
-             << std::to_string(VecSize) << "\");\n";
-  Indenter() << "    return " << ValueToReturn << ";\n";
-  Indenter() << "}\n\n";
-}
-
-// Generates code to ensure that the supplied array is non-null and nonzero in length.
-void RSReflectionCpp::genNullOrEmptyArrayCheck(const std::string &ArrayName,
-                                               const std::string &Length,
-                                               const std::string &ValueToReturn) {
-  mOut.indent() << "// Verify that the array is non-null and non-empty.\n";
-  mOut.indent() << "if (" << ArrayName << " == nullptr) {\n";
-  mOut.indent() << "    mRS->throwError(RS_ERROR_INVALID_PARAMETER, "
-                << "\"Input array is null\");\n";
-  mOut.indent() << "    return " << ValueToReturn << ";\n";
-  mOut.indent() << "}\n\n";
-
-  mOut.indent() << "if (" << Length << " == 0) {\n";
-  mOut.indent() << "    mRS->throwError(RS_ERROR_INVALID_PARAMETER, "
-                << "\"Input array is zero-length\");\n";
-  mOut.indent() << "    return " << ValueToReturn << ";\n";
-  mOut.indent() << "}\n\n";
-}
-
 void RSReflectionCpp::genTypeInstanceFromPointer(const RSExportType *ET) {
   if (ET->getClass() == RSExportType::ExportClassPointer) {
     // For pointer parameters to original forEach kernels.
diff --git a/slang_rs_reflection_cpp.h b/slang_rs_reflection_cpp.h
index 9c55ad8..c613d79 100644
--- a/slang_rs_reflection_cpp.h
+++ b/slang_rs_reflection_cpp.h
@@ -64,7 +64,6 @@
   unsigned int mNextExportVarSlot;
   unsigned int mNextExportFuncSlot;
   unsigned int mNextExportForEachSlot;
-  unsigned int mNextExportReduceSlot;
 
   // Generated RS Elements for type-checking code.
   std::set<std::string> mTypesToCheck;
@@ -73,7 +72,6 @@
     mNextExportVarSlot = 0;
     mNextExportFuncSlot = 0;
     mNextExportForEachSlot = 0;
-    mNextExportReduceSlot = 0;
     mTypesToCheck.clear();
   }
 
@@ -92,22 +90,15 @@
     return mNextExportForEachSlot++;
   }
 
-  inline unsigned int getNextExportReduceSlot() {
-    return mNextExportReduceSlot++;
-  }
-
   bool writeHeaderFile();
   bool writeImplementationFile();
 
   // Write out signatures both in the header and implementation.
   void makeFunctionSignature(bool isDefinition, const RSExportFunc *ef);
-  void makeReduceSignatureAllocationVariant(bool isDefinition, const RSExportReduce *er);
-  void makeReduceSignatureArrayVariant(bool isDefinition, const RSExportReduce *er);
 
   bool genEncodedBitCode();
   void genFieldsToStoreExportVariableValues();
   void genTypeInstancesUsedInForEach();
-  void genTypeInstancesUsedInReduce();
   void genFieldsForAllocationTypeVerification();
 
   // Write out the code for the getters and setters.
@@ -115,12 +106,10 @@
 
   // Write out the code for the declaration of the kernel entry points.
   void genForEachDeclarations();
-  void genReduceDeclarations();
   void genExportFunctionDeclarations();
 
   // Write out code for the definitions of the kernel entry points.
   void genExportForEachBodies();
-  void genExportReduceBodies();
   void genExportFunctionBodies();
 
   bool startScriptHeader();
@@ -156,19 +145,6 @@
   // Generate a runtime type check for VarName.
   void genTypeCheck(const RSExportType *ET, const char *VarName);
 
-  // Generate a runtime check that VarName is 1-dimensional.
-  void gen1DCheck(const std::string &VarName);
-
-  // Generate a runtime check that VarName is non-null.
-  void genNullOrEmptyArrayCheck(const std::string &ArrayName, const std::string &Length,
-                                const std::string &ValueToReturn);
-
-  // Generate a runtime check that ArrayName's length is a multiple of
-  // a vector size.
-  void genVectorLengthCompatibilityCheck(const std::string &Length, unsigned VecSize,
-                                         const std::string &ValueToReturn,
-                                         unsigned IndentLevels = 1);
-
   // Generate a type instance for a given type.
   void genTypeInstanceFromPointer(const RSExportType *ET);
   void genTypeInstance(const RSExportType *ET);
diff --git a/tests/F_kernel_badattr/kernel_badattr.rs b/tests/F_kernel_badattr/kernel_badattr.rs
index a719bd9..ef43d44 100644
--- a/tests/F_kernel_badattr/kernel_badattr.rs
+++ b/tests/F_kernel_badattr/kernel_badattr.rs
@@ -12,3 +12,7 @@
 int __attribute__((kernel("reduce", 1))) kernel3(int arg) {
   return 0;
 }
+
+int __attribute__((kernel("reduce"))) kernel4(int arg) {
+  return 0;
+}
diff --git a/tests/F_kernel_badattr/stderr.txt.expect b/tests/F_kernel_badattr/stderr.txt.expect
index 6cd1c74..0d206ad 100644
--- a/tests/F_kernel_badattr/stderr.txt.expect
+++ b/tests/F_kernel_badattr/stderr.txt.expect
@@ -1,3 +1,4 @@
 kernel_badattr.rs:8:27: error: 'kernel' attribute requires a string
 kernel_badattr.rs:12:20: error: 'kernel' attribute takes no more than 1 argument
 kernel_badattr.rs:4:46: error: Unknown kernel attribute argument 'unimplemented' in declaration of function 'kernel'
+kernel_badattr.rs:16:39: error: Unknown kernel attribute argument 'reduce' in declaration of function 'kernel4'
diff --git a/tests/F_reduce_api_unsupported/reduce_api_unsupported.rs b/tests/F_reduce_api_unsupported/reduce_api_unsupported.rs
deleted file mode 100644
index 8dfedfb..0000000
--- a/tests/F_reduce_api_unsupported/reduce_api_unsupported.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// -target-api 23
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-typedef struct foo {
-   int x;
-} foo;
-
-foo __attribute__((kernel("reduce"))) addFoo(foo a, foo b) {
-  foo result = { a.x + b.x };
-  return result;
-}
diff --git a/tests/F_reduce_api_unsupported/stderr.txt.expect b/tests/F_reduce_api_unsupported/stderr.txt.expect
deleted file mode 100644
index 0e389a4..0000000
--- a/tests/F_reduce_api_unsupported/stderr.txt.expect
+++ /dev/null
@@ -1 +0,0 @@
-reduce_api_unsupported.rs:9:39: error: Reduce-style kernel addFoo() unsupported in SDK level 23
diff --git a/tests/F_reduce_api_unsupported/stdout.txt.expect b/tests/F_reduce_api_unsupported/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/F_reduce_api_unsupported/stdout.txt.expect
+++ /dev/null
diff --git a/tests/F_reduce_non_binary/reduce_non_binary.rs b/tests/F_reduce_non_binary/reduce_non_binary.rs
deleted file mode 100644
index 77fdaa1..0000000
--- a/tests/F_reduce_non_binary/reduce_non_binary.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-/* 0 arguments */
-
-int __attribute__((kernel("reduce"))) kernel0(void) {
-  return 0;
-}
-
-/* 1 argument */
-
-int __attribute__((kernel("reduce"))) kernel1(int arg1) {
-  return 0;
-}
-
-/* 3 arguments */
-
-int __attribute__((kernel("reduce"))) kernel3(int arg1, int arg2, int arg3) {
-  return 0;
-}
-
-/* 4 arguments */
-
-int __attribute__((kernel("reduce"))) kernel4(int arg1, int arg2, int arg3, int arg4) {
-  return 0;
-}
diff --git a/tests/F_reduce_non_binary/stderr.txt.expect b/tests/F_reduce_non_binary/stderr.txt.expect
deleted file mode 100644
index 1463a21..0000000
--- a/tests/F_reduce_non_binary/stderr.txt.expect
+++ /dev/null
@@ -1,4 +0,0 @@
-reduce_non_binary.rs:7:39: error: Reduce-style kernel kernel0() must take 2 parameters (found 0).
-reduce_non_binary.rs:13:39: error: Reduce-style kernel kernel1() must take 2 parameters (found 1).
-reduce_non_binary.rs:19:39: error: Reduce-style kernel kernel3() must take 2 parameters (found 3).
-reduce_non_binary.rs:25:39: error: Reduce-style kernel kernel4() must take 2 parameters (found 4).
diff --git a/tests/F_reduce_non_binary/stdout.txt.expect b/tests/F_reduce_non_binary/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/F_reduce_non_binary/stdout.txt.expect
+++ /dev/null
diff --git a/tests/F_reduce_param_type_mismatch/reduce_param_type_mismatch.rs b/tests/F_reduce_param_type_mismatch/reduce_param_type_mismatch.rs
deleted file mode 100644
index fd8e1aa..0000000
--- a/tests/F_reduce_param_type_mismatch/reduce_param_type_mismatch.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-int __attribute__((kernel("reduce"))) kernel1(int arg1, float arg2) {
-  return 0;
-}
diff --git a/tests/F_reduce_param_type_mismatch/stderr.txt.expect b/tests/F_reduce_param_type_mismatch/stderr.txt.expect
deleted file mode 100644
index cc55737..0000000
--- a/tests/F_reduce_param_type_mismatch/stderr.txt.expect
+++ /dev/null
@@ -1,2 +0,0 @@
-reduce_param_type_mismatch.rs:5:39: error: Reduce-style kernel kernel1() return type 'int' is not the same type as parameter 'arg2' (type 'float')
-reduce_param_type_mismatch.rs:5:51: error: In reduce-style kernel kernel1(): parameter 'arg1' (type 'int') does not have the same type as parameter 'arg2' (type 'float')
diff --git a/tests/F_reduce_param_type_mismatch/stdout.txt.expect b/tests/F_reduce_param_type_mismatch/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/F_reduce_param_type_mismatch/stdout.txt.expect
+++ /dev/null
diff --git a/tests/F_reduce_ptr_param/reduce_ptr_param.rs b/tests/F_reduce_ptr_param/reduce_ptr_param.rs
deleted file mode 100644
index f099e19..0000000
--- a/tests/F_reduce_ptr_param/reduce_ptr_param.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-int __attribute__((kernel("reduce"))) kernel(int *arg1, int *arg2) {
-  return 0;
-}
diff --git a/tests/F_reduce_ptr_param/stderr.txt.expect b/tests/F_reduce_ptr_param/stderr.txt.expect
deleted file mode 100644
index 3dc971e..0000000
--- a/tests/F_reduce_ptr_param/stderr.txt.expect
+++ /dev/null
@@ -1,4 +0,0 @@
-reduce_ptr_param.rs:5:51: error: Reduce-style kernel kernel() cannot have parameter 'arg1' of pointer type: 'int *'
-reduce_ptr_param.rs:5:39: error: Reduce-style kernel kernel() return type 'int' is not the same type as parameter 'arg1' (type 'int *')
-reduce_ptr_param.rs:5:62: error: Reduce-style kernel kernel() cannot have parameter 'arg2' of pointer type: 'int *'
-reduce_ptr_param.rs:5:39: error: Reduce-style kernel kernel() return type 'int' is not the same type as parameter 'arg2' (type 'int *')
diff --git a/tests/F_reduce_ptr_param/stdout.txt.expect b/tests/F_reduce_ptr_param/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/F_reduce_ptr_param/stdout.txt.expect
+++ /dev/null
diff --git a/tests/F_reduce_ptr_ret_val/reduce_ptr_ret_val.rs b/tests/F_reduce_ptr_ret_val/reduce_ptr_ret_val.rs
deleted file mode 100644
index b1ee9c9..0000000
--- a/tests/F_reduce_ptr_ret_val/reduce_ptr_ret_val.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-int *__attribute__((kernel("reduce"))) kernel(int arg1, int arg2) {
-  return 0;
-}
diff --git a/tests/F_reduce_ptr_ret_val/stderr.txt.expect b/tests/F_reduce_ptr_ret_val/stderr.txt.expect
deleted file mode 100644
index 5e5852e..0000000
--- a/tests/F_reduce_ptr_ret_val/stderr.txt.expect
+++ /dev/null
@@ -1,3 +0,0 @@
-reduce_ptr_ret_val.rs:5:40: error: Reduce-style kernel kernel() cannot return a pointer type: int *
-reduce_ptr_ret_val.rs:5:40: error: Reduce-style kernel kernel() return type 'int *' is not the same type as parameter 'arg1' (type 'int')
-reduce_ptr_ret_val.rs:5:40: error: Reduce-style kernel kernel() return type 'int *' is not the same type as parameter 'arg2' (type 'int')
diff --git a/tests/F_reduce_ptr_ret_val/stdout.txt.expect b/tests/F_reduce_ptr_ret_val/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/F_reduce_ptr_ret_val/stdout.txt.expect
+++ /dev/null
diff --git a/tests/F_reduce_ret_type_mismatch/reduce_ret_type_mismatch.rs b/tests/F_reduce_ret_type_mismatch/reduce_ret_type_mismatch.rs
deleted file mode 100644
index e43ca89..0000000
--- a/tests/F_reduce_ret_type_mismatch/reduce_ret_type_mismatch.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-double __attribute__((kernel("reduce"))) kernel(float arg1, float arg2) {
-  return arg1 + arg2;
-}
diff --git a/tests/F_reduce_ret_type_mismatch/stderr.txt.expect b/tests/F_reduce_ret_type_mismatch/stderr.txt.expect
deleted file mode 100644
index e616c94..0000000
--- a/tests/F_reduce_ret_type_mismatch/stderr.txt.expect
+++ /dev/null
@@ -1,2 +0,0 @@
-reduce_ret_type_mismatch.rs:5:42: error: Reduce-style kernel kernel() return type 'double' is not the same type as parameter 'arg1' (type 'float')
-reduce_ret_type_mismatch.rs:5:42: error: Reduce-style kernel kernel() return type 'double' is not the same type as parameter 'arg2' (type 'float')
diff --git a/tests/F_reduce_ret_type_mismatch/stdout.txt.expect b/tests/F_reduce_ret_type_mismatch/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/F_reduce_ret_type_mismatch/stdout.txt.expect
+++ /dev/null
diff --git a/tests/F_reduce_void_ret/reduce_void_ret.rs b/tests/F_reduce_void_ret/reduce_void_ret.rs
deleted file mode 100644
index 8fecfc2..0000000
--- a/tests/F_reduce_void_ret/reduce_void_ret.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-void __attribute__((kernel("reduce"))) kernel(int arg1, int arg2) {
-  return;
-}
diff --git a/tests/F_reduce_void_ret/stderr.txt.expect b/tests/F_reduce_void_ret/stderr.txt.expect
deleted file mode 100644
index ecb3dd1..0000000
--- a/tests/F_reduce_void_ret/stderr.txt.expect
+++ /dev/null
@@ -1,3 +0,0 @@
-reduce_void_ret.rs:5:40: error: Reduce-style kernel kernel() cannot return void
-reduce_void_ret.rs:5:40: error: Reduce-style kernel kernel() return type 'void' is not the same type as parameter 'arg1' (type 'int')
-reduce_void_ret.rs:5:40: error: Reduce-style kernel kernel() return type 'void' is not the same type as parameter 'arg2' (type 'int')
diff --git a/tests/F_reduce_void_ret/stdout.txt.expect b/tests/F_reduce_void_ret/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/F_reduce_void_ret/stdout.txt.expect
+++ /dev/null
diff --git a/tests/P_reduce/reduce.rs b/tests/P_reduce/reduce.rs
deleted file mode 100644
index 4017f79..0000000
--- a/tests/P_reduce/reduce.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-bool __attribute__((kernel("reduce")))
-mul_bool(bool lhs, bool rhs) {
-  return lhs * rhs;
-}
-
-char __attribute__((kernel("reduce")))
-mul_char(char lhs, char rhs) {
-  return lhs * rhs;
-}
-
-char2 __attribute__((kernel("reduce")))
-mul_char2(char2 lhs, char2 rhs) {
-  return lhs * rhs;
-}
-
-char3 __attribute__((kernel("reduce")))
-mul_char3(char3 lhs, char3 rhs) {
-  return lhs * rhs;
-}
-
-char4 __attribute__((kernel("reduce")))
-mul_char4(char4 lhs, char4 rhs) {
-  return lhs * rhs;
-}
-
-double __attribute__((kernel("reduce")))
-mul_double(double lhs, double rhs) {
-  return lhs * rhs;
-}
-
-double2 __attribute__((kernel("reduce")))
-mul_double2(double2 lhs, double2 rhs) {
-  return lhs * rhs;
-}
-
-double3 __attribute__((kernel("reduce")))
-mul_double3(double3 lhs, double3 rhs) {
-  return lhs * rhs;
-}
-
-double4 __attribute__((kernel("reduce")))
-mul_double4(double4 lhs, double4 rhs) {
-  return lhs * rhs;
-}
-
-float __attribute__((kernel("reduce")))
-mul_float(float lhs, float rhs) {
-  return lhs * rhs;
-}
-
-float2 __attribute__((kernel("reduce")))
-mul_float2(float2 lhs, float2 rhs) {
-  return lhs * rhs;
-}
-
-float3 __attribute__((kernel("reduce")))
-mul_float3(float3 lhs, float3 rhs) {
-  return lhs * rhs;
-}
-
-float4 __attribute__((kernel("reduce")))
-mul_float4(float4 lhs, float4 rhs) {
-  return lhs * rhs;
-}
-
-int __attribute__((kernel("reduce")))
-mul_int(int lhs, int rhs) {
-  return lhs * rhs;
-}
-
-int2 __attribute__((kernel("reduce")))
-mul_int2(int2 lhs, int2 rhs) {
-  return lhs * rhs;
-}
-
-int3 __attribute__((kernel("reduce")))
-mul_int3(int3 lhs, int3 rhs) {
-  return lhs * rhs;
-}
-
-int4 __attribute__((kernel("reduce")))
-mul_int4(int4 lhs, int4 rhs) {
-  return lhs * rhs;
-}
-
-long __attribute__((kernel("reduce")))
-mul_long(long lhs, long rhs) {
-  return lhs * rhs;
-}
-
-long2 __attribute__((kernel("reduce")))
-mul_long2(long2 lhs, long2 rhs) {
-  return lhs * rhs;
-}
-
-long3 __attribute__((kernel("reduce")))
-mul_long3(long3 lhs, long3 rhs) {
-  return lhs * rhs;
-}
-
-long4 __attribute__((kernel("reduce")))
-mul_long4(long4 lhs, long4 rhs) {
-  return lhs * rhs;
-}
-
-short __attribute__((kernel("reduce")))
-mul_short(short lhs, short rhs) {
-  return lhs * rhs;
-}
-
-short2 __attribute__((kernel("reduce")))
-mul_short2(short2 lhs, short2 rhs) {
-  return lhs * rhs;
-}
-
-short3 __attribute__((kernel("reduce")))
-mul_short3(short3 lhs, short3 rhs) {
-  return lhs * rhs;
-}
-
-short4 __attribute__((kernel("reduce")))
-mul_short4(short4 lhs, short4 rhs) {
-  return lhs * rhs;
-}
-
-uchar __attribute__((kernel("reduce")))
-mul_uchar(uchar lhs, uchar rhs) {
-  return lhs * rhs;
-}
-
-uchar2 __attribute__((kernel("reduce")))
-mul_uchar2(uchar2 lhs, uchar2 rhs) {
-  return lhs * rhs;
-}
-
-uchar3 __attribute__((kernel("reduce")))
-mul_uchar3(uchar3 lhs, uchar3 rhs) {
-  return lhs * rhs;
-}
-
-uchar4 __attribute__((kernel("reduce")))
-mul_uchar4(uchar4 lhs, uchar4 rhs) {
-  return lhs * rhs;
-}
-
-uint __attribute__((kernel("reduce")))
-mul_uint(uint lhs, uint rhs) {
-  return lhs * rhs;
-}
-
-uint2 __attribute__((kernel("reduce")))
-mul_uint2(uint2 lhs, uint2 rhs) {
-  return lhs * rhs;
-}
-
-uint3 __attribute__((kernel("reduce")))
-mul_uint3(uint3 lhs, uint3 rhs) {
-  return lhs * rhs;
-}
-
-uint4 __attribute__((kernel("reduce")))
-mul_uint4(uint4 lhs, uint4 rhs) {
-  return lhs * rhs;
-}
-
-ulong __attribute__((kernel("reduce")))
-mul_ulong(ulong lhs, ulong rhs) {
-  return lhs * rhs;
-}
-
-ulong2 __attribute__((kernel("reduce")))
-mul_ulong2(ulong2 lhs, ulong2 rhs) {
-  return lhs * rhs;
-}
-
-ulong3 __attribute__((kernel("reduce")))
-mul_ulong3(ulong3 lhs, ulong3 rhs) {
-  return lhs * rhs;
-}
-
-ulong4 __attribute__((kernel("reduce")))
-mul_ulong4(ulong4 lhs, ulong4 rhs) {
-  return lhs * rhs;
-}
-
-ushort __attribute__((kernel("reduce")))
-mul_ushort(ushort lhs, ushort rhs) {
-  return lhs * rhs;
-}
-
-ushort2 __attribute__((kernel("reduce")))
-mul_ushort2(ushort2 lhs, ushort2 rhs) {
-  return lhs * rhs;
-}
-
-ushort3 __attribute__((kernel("reduce")))
-mul_ushort3(ushort3 lhs, ushort3 rhs) {
-  return lhs * rhs;
-}
-
-ushort4 __attribute__((kernel("reduce")))
-mul_ushort4(ushort4 lhs, ushort4 rhs) {
-  return lhs * rhs;
-}
-
-struct indirect {
-  bool elem_bool;
-  char elem_char;
-  char2 elem_char2;
-  char3 elem_char3;
-  char4 elem_char4;
-  double elem_double;
-  double2 elem_double2;
-  double3 elem_double3;
-  double4 elem_double4;
-  float elem_float;
-  float2 elem_float2;
-  float3 elem_float3;
-  float4 elem_float4;
-  int elem_int;
-  int2 elem_int2;
-  int3 elem_int3;
-  int4 elem_int4;
-  long elem_long;
-  long2 elem_long2;
-  long3 elem_long3;
-  long4 elem_long4;
-  short elem_short;
-  short2 elem_short2;
-  short3 elem_short3;
-  short4 elem_short4;
-  uchar elem_uchar;
-  uchar2 elem_uchar2;
-  uchar3 elem_uchar3;
-  uchar4 elem_uchar4;
-  uint elem_uint;
-  uint2 elem_uint2;
-  uint3 elem_uint3;
-  uint4 elem_uint4;
-  ulong elem_ulong;
-  ulong2 elem_ulong2;
-  ulong3 elem_ulong3;
-  ulong4 elem_ulong4;
-  ushort elem_ushort;
-  ushort2 elem_ushort2;
-  ushort3 elem_ushort3;
-  ushort4 elem_ushort4;
-};
-
-struct indirect __attribute__((kernel("reduce")))
-mul_indirect(struct indirect lhs, struct indirect rhs) {
-  lhs.elem_bool *= rhs.elem_bool;
-  lhs.elem_char *= rhs.elem_char;
-  lhs.elem_char2 *= rhs.elem_char2;
-  lhs.elem_char3 *= rhs.elem_char3;
-  lhs.elem_char4 *= rhs.elem_char4;
-  lhs.elem_double *= rhs.elem_double;
-  lhs.elem_double2 *= rhs.elem_double2;
-  lhs.elem_double3 *= rhs.elem_double3;
-  lhs.elem_double4 *= rhs.elem_double4;
-  lhs.elem_float *= rhs.elem_float;
-  lhs.elem_float2 *= rhs.elem_float2;
-  lhs.elem_float3 *= rhs.elem_float3;
-  lhs.elem_float4 *= rhs.elem_float4;
-  lhs.elem_int *= rhs.elem_int;
-  lhs.elem_int2 *= rhs.elem_int2;
-  lhs.elem_int3 *= rhs.elem_int3;
-  lhs.elem_int4 *= rhs.elem_int4;
-  lhs.elem_long *= rhs.elem_long;
-  lhs.elem_long2 *= rhs.elem_long2;
-  lhs.elem_long3 *= rhs.elem_long3;
-  lhs.elem_long4 *= rhs.elem_long4;
-  lhs.elem_short *= rhs.elem_short;
-  lhs.elem_short2 *= rhs.elem_short2;
-  lhs.elem_short3 *= rhs.elem_short3;
-  lhs.elem_short4 *= rhs.elem_short4;
-  lhs.elem_uchar *= rhs.elem_uchar;
-  lhs.elem_uchar2 *= rhs.elem_uchar2;
-  lhs.elem_uchar3 *= rhs.elem_uchar3;
-  lhs.elem_uchar4 *= rhs.elem_uchar4;
-  lhs.elem_uint *= rhs.elem_uint;
-  lhs.elem_uint2 *= rhs.elem_uint2;
-  lhs.elem_uint3 *= rhs.elem_uint3;
-  lhs.elem_uint4 *= rhs.elem_uint4;
-  lhs.elem_ulong *= rhs.elem_ulong;
-  lhs.elem_ulong2 *= rhs.elem_ulong2;
-  lhs.elem_ulong3 *= rhs.elem_ulong3;
-  lhs.elem_ulong4 *= rhs.elem_ulong4;
-  lhs.elem_ushort *= rhs.elem_ushort;
-  lhs.elem_ushort2 *= rhs.elem_ushort2;
-  lhs.elem_ushort3 *= rhs.elem_ushort3;
-  lhs.elem_ushort4 *= rhs.elem_ushort4;
-  return lhs;
-}
diff --git a/tests/P_reduce/stderr.txt.expect b/tests/P_reduce/stderr.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/P_reduce/stderr.txt.expect
+++ /dev/null
diff --git a/tests/P_reduce/stdout.txt.expect b/tests/P_reduce/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/P_reduce/stdout.txt.expect
+++ /dev/null
diff --git a/tests/P_reduce_cpp/reduce_cpp.rs b/tests/P_reduce_cpp/reduce_cpp.rs
deleted file mode 100644
index a4ddeb5..0000000
--- a/tests/P_reduce_cpp/reduce_cpp.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// -target-api 0 -reflect-c++
-
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-int __attribute__((kernel("reduce"))) add(int a, int b) {
-  return a + b;
-}
diff --git a/tests/P_reduce_cpp/stderr.txt.expect b/tests/P_reduce_cpp/stderr.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/P_reduce_cpp/stderr.txt.expect
+++ /dev/null
diff --git a/tests/P_reduce_cpp/stdout.txt.expect b/tests/P_reduce_cpp/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/P_reduce_cpp/stdout.txt.expect
+++ /dev/null
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
index 8d75878..c39ce7c 100644
--- a/tests/P_reduce_general_accumulator/ScriptC_reduce_general_accumulator.java.expect
+++ b/tests/P_reduce_general_accumulator/ScriptC_reduce_general_accumulator.java.expect
@@ -77,7 +77,7 @@
         private int mResult;
     }
 
-    private final static int mExportReduceNewIdx_my_half = 0;
+    private final static int mExportReduceIdx_my_half = 0;
     // in1 = "val"
     public result_int reduce_my_half(int[] in1) {
         // Verify that "in1" is non-null.
@@ -106,11 +106,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2 = 1;
+    private final static int mExportReduceIdx_my_half2 = 1;
     // in1 = "val"
     public result_int reduce_my_half2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -139,11 +139,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4 = 2;
+    private final static int mExportReduceIdx_my_half4 = 2;
     // in1 = "val"
     public result_int reduce_my_half4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -172,11 +172,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_half = 3;
+    private final static int mExportReduceIdx_my_array_half = 3;
     // in1 = "val"
     public result_int reduce_my_array_half(int[] in1) {
         // Verify that "in1" is non-null.
@@ -205,11 +205,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_half, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_half, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_half2 = 4;
+    private final static int mExportReduceIdx_my_array_half2 = 4;
     // in1 = "val"
     public result_int reduce_my_array_half2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -238,11 +238,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_half2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_half2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_half4 = 5;
+    private final static int mExportReduceIdx_my_array_half4 = 5;
     // in1 = "val"
     public result_int reduce_my_array_half4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -271,11 +271,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_half4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_half4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float = 6;
+    private final static int mExportReduceIdx_my_float = 6;
     // in1 = "val"
     public result_int reduce_my_float(int[] in1) {
         // Verify that "in1" is non-null.
@@ -304,11 +304,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2 = 7;
+    private final static int mExportReduceIdx_my_float2 = 7;
     // in1 = "val"
     public result_int reduce_my_float2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -337,11 +337,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4 = 8;
+    private final static int mExportReduceIdx_my_float4 = 8;
     // in1 = "val"
     public result_int reduce_my_float4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -370,11 +370,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float = 9;
+    private final static int mExportReduceIdx_my_array_float = 9;
     // in1 = "val"
     public result_int reduce_my_array_float(int[] in1) {
         // Verify that "in1" is non-null.
@@ -403,11 +403,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_float, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_float, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float2 = 10;
+    private final static int mExportReduceIdx_my_array_float2 = 10;
     // in1 = "val"
     public result_int reduce_my_array_float2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -436,11 +436,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_float2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_float2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float4 = 11;
+    private final static int mExportReduceIdx_my_array_float4 = 11;
     // in1 = "val"
     public result_int reduce_my_array_float4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -469,11 +469,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_float4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_float4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double = 12;
+    private final static int mExportReduceIdx_my_double = 12;
     // in1 = "val"
     public result_int reduce_my_double(int[] in1) {
         // Verify that "in1" is non-null.
@@ -502,11 +502,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2 = 13;
+    private final static int mExportReduceIdx_my_double2 = 13;
     // in1 = "val"
     public result_int reduce_my_double2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -535,11 +535,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4 = 14;
+    private final static int mExportReduceIdx_my_double4 = 14;
     // in1 = "val"
     public result_int reduce_my_double4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -568,11 +568,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double = 15;
+    private final static int mExportReduceIdx_my_array_double = 15;
     // in1 = "val"
     public result_int reduce_my_array_double(int[] in1) {
         // Verify that "in1" is non-null.
@@ -601,11 +601,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_double, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_double, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double2 = 16;
+    private final static int mExportReduceIdx_my_array_double2 = 16;
     // in1 = "val"
     public result_int reduce_my_array_double2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -634,11 +634,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_double2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_double2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double4 = 17;
+    private final static int mExportReduceIdx_my_array_double4 = 17;
     // in1 = "val"
     public result_int reduce_my_array_double4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -667,11 +667,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_double4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_double4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char = 18;
+    private final static int mExportReduceIdx_my_char = 18;
     // in1 = "val"
     public result_int reduce_my_char(int[] in1) {
         // Verify that "in1" is non-null.
@@ -700,11 +700,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2 = 19;
+    private final static int mExportReduceIdx_my_char2 = 19;
     // in1 = "val"
     public result_int reduce_my_char2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -733,11 +733,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4 = 20;
+    private final static int mExportReduceIdx_my_char4 = 20;
     // in1 = "val"
     public result_int reduce_my_char4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -766,11 +766,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char = 21;
+    private final static int mExportReduceIdx_my_array_char = 21;
     // in1 = "val"
     public result_int reduce_my_array_char(int[] in1) {
         // Verify that "in1" is non-null.
@@ -799,11 +799,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_char, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_char, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char2 = 22;
+    private final static int mExportReduceIdx_my_array_char2 = 22;
     // in1 = "val"
     public result_int reduce_my_array_char2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -832,11 +832,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_char2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_char2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char4 = 23;
+    private final static int mExportReduceIdx_my_array_char4 = 23;
     // in1 = "val"
     public result_int reduce_my_array_char4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -865,11 +865,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_char4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_char4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short = 24;
+    private final static int mExportReduceIdx_my_short = 24;
     // in1 = "val"
     public result_int reduce_my_short(int[] in1) {
         // Verify that "in1" is non-null.
@@ -898,11 +898,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2 = 25;
+    private final static int mExportReduceIdx_my_short2 = 25;
     // in1 = "val"
     public result_int reduce_my_short2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -931,11 +931,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4 = 26;
+    private final static int mExportReduceIdx_my_short4 = 26;
     // in1 = "val"
     public result_int reduce_my_short4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -964,11 +964,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short = 27;
+    private final static int mExportReduceIdx_my_array_short = 27;
     // in1 = "val"
     public result_int reduce_my_array_short(int[] in1) {
         // Verify that "in1" is non-null.
@@ -997,11 +997,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_short, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_short, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short2 = 28;
+    private final static int mExportReduceIdx_my_array_short2 = 28;
     // in1 = "val"
     public result_int reduce_my_array_short2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1030,11 +1030,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_short2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_short2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short4 = 29;
+    private final static int mExportReduceIdx_my_array_short4 = 29;
     // in1 = "val"
     public result_int reduce_my_array_short4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1063,11 +1063,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_short4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_short4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int = 30;
+    private final static int mExportReduceIdx_my_int = 30;
     // in1 = "val"
     public result_int reduce_my_int(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1096,11 +1096,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2 = 31;
+    private final static int mExportReduceIdx_my_int2 = 31;
     // in1 = "val"
     public result_int reduce_my_int2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1129,11 +1129,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4 = 32;
+    private final static int mExportReduceIdx_my_int4 = 32;
     // in1 = "val"
     public result_int reduce_my_int4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1162,11 +1162,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int = 33;
+    private final static int mExportReduceIdx_my_array_int = 33;
     // in1 = "val"
     public result_int reduce_my_array_int(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1195,11 +1195,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_int, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_int, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int2 = 34;
+    private final static int mExportReduceIdx_my_array_int2 = 34;
     // in1 = "val"
     public result_int reduce_my_array_int2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1228,11 +1228,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_int2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_int2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int4 = 35;
+    private final static int mExportReduceIdx_my_array_int4 = 35;
     // in1 = "val"
     public result_int reduce_my_array_int4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1261,11 +1261,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_int4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_int4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long = 36;
+    private final static int mExportReduceIdx_my_long = 36;
     // in1 = "val"
     public result_int reduce_my_long(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1294,11 +1294,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2 = 37;
+    private final static int mExportReduceIdx_my_long2 = 37;
     // in1 = "val"
     public result_int reduce_my_long2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1327,11 +1327,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4 = 38;
+    private final static int mExportReduceIdx_my_long4 = 38;
     // in1 = "val"
     public result_int reduce_my_long4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1360,11 +1360,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long = 39;
+    private final static int mExportReduceIdx_my_array_long = 39;
     // in1 = "val"
     public result_int reduce_my_array_long(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1393,11 +1393,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_long, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_long, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long2 = 40;
+    private final static int mExportReduceIdx_my_array_long2 = 40;
     // in1 = "val"
     public result_int reduce_my_array_long2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1426,11 +1426,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_long2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_long2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long4 = 41;
+    private final static int mExportReduceIdx_my_array_long4 = 41;
     // in1 = "val"
     public result_int reduce_my_array_long4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1459,11 +1459,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_long4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_long4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar = 42;
+    private final static int mExportReduceIdx_my_uchar = 42;
     // in1 = "val"
     public result_int reduce_my_uchar(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1492,11 +1492,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2 = 43;
+    private final static int mExportReduceIdx_my_uchar2 = 43;
     // in1 = "val"
     public result_int reduce_my_uchar2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1525,11 +1525,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4 = 44;
+    private final static int mExportReduceIdx_my_uchar4 = 44;
     // in1 = "val"
     public result_int reduce_my_uchar4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1558,11 +1558,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar = 45;
+    private final static int mExportReduceIdx_my_array_uchar = 45;
     // in1 = "val"
     public result_int reduce_my_array_uchar(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1591,11 +1591,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uchar, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uchar, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar2 = 46;
+    private final static int mExportReduceIdx_my_array_uchar2 = 46;
     // in1 = "val"
     public result_int reduce_my_array_uchar2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1624,11 +1624,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uchar2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uchar2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar4 = 47;
+    private final static int mExportReduceIdx_my_array_uchar4 = 47;
     // in1 = "val"
     public result_int reduce_my_array_uchar4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1657,11 +1657,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uchar4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uchar4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort = 48;
+    private final static int mExportReduceIdx_my_ushort = 48;
     // in1 = "val"
     public result_int reduce_my_ushort(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1690,11 +1690,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2 = 49;
+    private final static int mExportReduceIdx_my_ushort2 = 49;
     // in1 = "val"
     public result_int reduce_my_ushort2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1723,11 +1723,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4 = 50;
+    private final static int mExportReduceIdx_my_ushort4 = 50;
     // in1 = "val"
     public result_int reduce_my_ushort4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1756,11 +1756,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort = 51;
+    private final static int mExportReduceIdx_my_array_ushort = 51;
     // in1 = "val"
     public result_int reduce_my_array_ushort(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1789,11 +1789,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ushort, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ushort, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort2 = 52;
+    private final static int mExportReduceIdx_my_array_ushort2 = 52;
     // in1 = "val"
     public result_int reduce_my_array_ushort2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1822,11 +1822,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ushort2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ushort2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort4 = 53;
+    private final static int mExportReduceIdx_my_array_ushort4 = 53;
     // in1 = "val"
     public result_int reduce_my_array_ushort4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1855,11 +1855,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ushort4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ushort4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint = 54;
+    private final static int mExportReduceIdx_my_uint = 54;
     // in1 = "val"
     public result_int reduce_my_uint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1888,11 +1888,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2 = 55;
+    private final static int mExportReduceIdx_my_uint2 = 55;
     // in1 = "val"
     public result_int reduce_my_uint2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1921,11 +1921,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4 = 56;
+    private final static int mExportReduceIdx_my_uint4 = 56;
     // in1 = "val"
     public result_int reduce_my_uint4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1954,11 +1954,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint = 57;
+    private final static int mExportReduceIdx_my_array_uint = 57;
     // in1 = "val"
     public result_int reduce_my_array_uint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -1987,11 +1987,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uint, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint2 = 58;
+    private final static int mExportReduceIdx_my_array_uint2 = 58;
     // in1 = "val"
     public result_int reduce_my_array_uint2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2020,11 +2020,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uint2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uint2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint4 = 59;
+    private final static int mExportReduceIdx_my_array_uint4 = 59;
     // in1 = "val"
     public result_int reduce_my_array_uint4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2053,11 +2053,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uint4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uint4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong = 60;
+    private final static int mExportReduceIdx_my_ulong = 60;
     // in1 = "val"
     public result_int reduce_my_ulong(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2086,11 +2086,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2 = 61;
+    private final static int mExportReduceIdx_my_ulong2 = 61;
     // in1 = "val"
     public result_int reduce_my_ulong2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2119,11 +2119,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4 = 62;
+    private final static int mExportReduceIdx_my_ulong4 = 62;
     // in1 = "val"
     public result_int reduce_my_ulong4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2152,11 +2152,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong = 63;
+    private final static int mExportReduceIdx_my_array_ulong = 63;
     // in1 = "val"
     public result_int reduce_my_array_ulong(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2185,11 +2185,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ulong, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ulong, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong2 = 64;
+    private final static int mExportReduceIdx_my_array_ulong2 = 64;
     // in1 = "val"
     public result_int reduce_my_array_ulong2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2218,11 +2218,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ulong2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ulong2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong4 = 65;
+    private final static int mExportReduceIdx_my_array_ulong4 = 65;
     // in1 = "val"
     public result_int reduce_my_array_ulong4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2251,11 +2251,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ulong4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ulong4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool = 66;
+    private final static int mExportReduceIdx_my_bool = 66;
     // in1 = "val"
     public result_int reduce_my_bool(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2284,11 +2284,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_bool = 67;
+    private final static int mExportReduceIdx_my_array_bool = 67;
     // in1 = "val"
     public result_int reduce_my_array_bool(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2317,11 +2317,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_bool, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_bool, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2 = 68;
+    private final static int mExportReduceIdx_my_rs_matrix2x2 = 68;
     // in1 = "val"
     public result_int reduce_my_rs_matrix2x2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2350,11 +2350,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_rs_matrix2x2 = 69;
+    private final static int mExportReduceIdx_my_array_rs_matrix2x2 = 69;
     // in1 = "val"
     public result_int reduce_my_array_rs_matrix2x2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2383,11 +2383,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_rs_matrix2x2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_rs_matrix2x2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3 = 70;
+    private final static int mExportReduceIdx_my_rs_matrix3x3 = 70;
     // in1 = "val"
     public result_int reduce_my_rs_matrix3x3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2416,11 +2416,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_rs_matrix3x3 = 71;
+    private final static int mExportReduceIdx_my_array_rs_matrix3x3 = 71;
     // in1 = "val"
     public result_int reduce_my_array_rs_matrix3x3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2449,11 +2449,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_rs_matrix3x3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_rs_matrix3x3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4 = 72;
+    private final static int mExportReduceIdx_my_rs_matrix4x4 = 72;
     // in1 = "val"
     public result_int reduce_my_rs_matrix4x4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2482,11 +2482,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_rs_matrix4x4 = 73;
+    private final static int mExportReduceIdx_my_array_rs_matrix4x4 = 73;
     // in1 = "val"
     public result_int reduce_my_array_rs_matrix4x4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2515,11 +2515,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_rs_matrix4x4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_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;
+    private final static int mExportReduceIdx_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.
@@ -2548,11 +2548,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_for_each_strategy_t, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_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;
+    private final static int mExportReduceIdx_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.
@@ -2581,11 +2581,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_rs_for_each_strategy_t, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_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;
+    private final static int mExportReduceIdx_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.
@@ -2614,11 +2614,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_script_call_t, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_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;
+    private final static int mExportReduceIdx_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.
@@ -2647,11 +2647,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_rs_script_call_t, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_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;
+    private final static int mExportReduceIdx_my_rs_time_t = 78;
     // in1 = "val"
     public result_int reduce_my_rs_time_t(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2680,11 +2680,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_time_t, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_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;
+    private final static int mExportReduceIdx_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.
@@ -2713,11 +2713,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_rs_time_t, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_rs_time_t, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_tm = 80;
+    private final static int mExportReduceIdx_my_rs_tm = 80;
     // in1 = "val"
     public result_int reduce_my_rs_tm(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2746,11 +2746,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_tm, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_tm, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_rs_tm = 81;
+    private final static int mExportReduceIdx_my_array_rs_tm = 81;
     // in1 = "val"
     public result_int reduce_my_array_rs_tm(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2779,11 +2779,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_rs_tm, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_rs_tm, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyEnum = 82;
+    private final static int mExportReduceIdx_my_MyEnum = 82;
     // in1 = "val"
     public result_int reduce_my_MyEnum(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2812,11 +2812,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyEnum, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyEnum, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyEnum = 83;
+    private final static int mExportReduceIdx_my_array_MyEnum = 83;
     // in1 = "val"
     public result_int reduce_my_array_MyEnum(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2845,11 +2845,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyEnum, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyEnum, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyPtrArray = 84;
+    private final static int mExportReduceIdx_my_MyPtrArray = 84;
     // in1 = "val"
     public result_int reduce_my_MyPtrArray(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2878,11 +2878,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyPtrArray, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyPtrArray, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyPtrArray = 85;
+    private final static int mExportReduceIdx_my_array_MyPtrArray = 85;
     // in1 = "val"
     public result_int reduce_my_array_MyPtrArray(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2911,11 +2911,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyPtrArray, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyPtrArray, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyPtrFn = 86;
+    private final static int mExportReduceIdx_my_MyPtrFn = 86;
     // in1 = "val"
     public result_int reduce_my_MyPtrFn(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2944,11 +2944,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyPtrFn, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyPtrFn, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyPtrFn = 87;
+    private final static int mExportReduceIdx_my_array_MyPtrFn = 87;
     // in1 = "val"
     public result_int reduce_my_array_MyPtrFn(int[] in1) {
         // Verify that "in1" is non-null.
@@ -2977,11 +2977,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyPtrFn, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyPtrFn, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyPtrIncomplete = 88;
+    private final static int mExportReduceIdx_my_MyPtrIncomplete = 88;
     // in1 = "val"
     public result_int reduce_my_MyPtrIncomplete(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3010,11 +3010,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyPtrIncomplete, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyPtrIncomplete, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyPtrIncomplete = 89;
+    private final static int mExportReduceIdx_my_array_MyPtrIncomplete = 89;
     // in1 = "val"
     public result_int reduce_my_array_MyPtrIncomplete(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3043,11 +3043,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyPtrIncomplete, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyPtrIncomplete, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyPtrShort = 90;
+    private final static int mExportReduceIdx_my_MyPtrShort = 90;
     // in1 = "val"
     public result_int reduce_my_MyPtrShort(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3076,11 +3076,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyPtrShort, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyPtrShort, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyPtrShort = 91;
+    private final static int mExportReduceIdx_my_array_MyPtrShort = 91;
     // in1 = "val"
     public result_int reduce_my_array_MyPtrShort(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3109,11 +3109,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyPtrShort, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyPtrShort, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyPtrVoid = 92;
+    private final static int mExportReduceIdx_my_MyPtrVoid = 92;
     // in1 = "val"
     public result_int reduce_my_MyPtrVoid(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3142,11 +3142,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyPtrVoid, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyPtrVoid, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyPtrVoid = 93;
+    private final static int mExportReduceIdx_my_array_MyPtrVoid = 93;
     // in1 = "val"
     public result_int reduce_my_array_MyPtrVoid(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3175,11 +3175,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyPtrVoid, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyPtrVoid, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct = 94;
+    private final static int mExportReduceIdx_my_MyStruct = 94;
     // in1 = "val"
     public result_int reduce_my_MyStruct(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3208,11 +3208,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyStruct = 95;
+    private final static int mExportReduceIdx_my_array_MyStruct = 95;
     // in1 = "val"
     public result_int reduce_my_array_MyStruct(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3241,11 +3241,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyStruct, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyStruct, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyUnion = 96;
+    private final static int mExportReduceIdx_my_MyUnion = 96;
     // in1 = "val"
     public result_int reduce_my_MyUnion(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3274,11 +3274,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyUnion, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyUnion, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyUnion = 97;
+    private final static int mExportReduceIdx_my_array_MyUnion = 97;
     // in1 = "val"
     public result_int reduce_my_array_MyUnion(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3307,11 +3307,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyUnion, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyUnion, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyBlob = 98;
+    private final static int mExportReduceIdx_my_MyBlob = 98;
     // in1 = "val"
     public result_int reduce_my_MyBlob(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3340,11 +3340,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyBlob, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyBlob, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_MyBlob = 99;
+    private final static int mExportReduceIdx_my_array_MyBlob = 99;
     // in1 = "val"
     public result_int reduce_my_array_MyBlob(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3373,7 +3373,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_MyBlob, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_MyBlob, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
diff --git a/tests/P_reduce_general_duplicate_array/ScriptC_reduce_general_duplicate_array.java.expect b/tests/P_reduce_general_duplicate_array/ScriptC_reduce_general_duplicate_array.java.expect
index bc32c17..c4d88ab 100644
--- a/tests/P_reduce_general_duplicate_array/ScriptC_reduce_general_duplicate_array.java.expect
+++ b/tests/P_reduce_general_duplicate_array/ScriptC_reduce_general_duplicate_array.java.expect
@@ -77,7 +77,7 @@
         private int[] mResult;
     }
 
-    private final static int mExportReduceNewIdx_sumDec = 0;
+    private final static int mExportReduceIdx_sumDec = 0;
     // in1 = "val"
     public resultArray4_int reduce_sumDec(int[] in1) {
         // Verify that "in1" is non-null.
@@ -106,11 +106,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 4);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_sumDec, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_sumDec, new Allocation[]{ain1}, aout, sc);
         return new resultArray4_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_sumInc = 1;
+    private final static int mExportReduceIdx_sumInc = 1;
     // in1 = "val"
     public resultArray4_int reduce_sumInc(int[] in1) {
         // Verify that "in1" is non-null.
@@ -139,7 +139,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 4);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_sumInc, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_sumInc, new Allocation[]{ain1}, aout, sc);
         return new resultArray4_int(aout);
     }
 
diff --git a/tests/P_reduce_general_examples/ScriptC_reduce_general_examples.java.expect b/tests/P_reduce_general_examples/ScriptC_reduce_general_examples.java.expect
index 0d61a74..74b295e 100644
--- a/tests/P_reduce_general_examples/ScriptC_reduce_general_examples.java.expect
+++ b/tests/P_reduce_general_examples/ScriptC_reduce_general_examples.java.expect
@@ -198,7 +198,7 @@
         private Int2 mResult;
     }
 
-    private final static int mExportReduceNewIdx_addint = 0;
+    private final static int mExportReduceIdx_addint = 0;
     // in1 = "val"
     public result_int reduce_addint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -227,11 +227,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_addint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_addint, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_mpyint = 1;
+    private final static int mExportReduceIdx_mpyint = 1;
     // in1 = "val"
     public result_int reduce_mpyint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -260,11 +260,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_mpyint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_mpyint, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_dp = 2;
+    private final static int mExportReduceIdx_dp = 2;
     // in1 = "in1"
     // in2 = "in2"
     public result_float reduce_dp(float[] in1, float[] in2) {
@@ -324,11 +324,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __F32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_dp, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_dp, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_float(aout);
     }
 
-    private final static int mExportReduceNewIdx_findMinAndMax = 3;
+    private final static int mExportReduceIdx_findMinAndMax = 3;
     // in1 = "in"
     public result_int2 reduce_findMinAndMax(float[] in1) {
         // Verify that "in1" is non-null.
@@ -357,11 +357,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_findMinAndMax, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_findMinAndMax, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_fz = 4;
+    private final static int mExportReduceIdx_fz = 4;
     // in1 = "inVal"
     public result_int reduce_fz(int[] in1) {
         // Verify that "in1" is non-null.
@@ -390,11 +390,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_fz, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_fz, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_fz2 = 5;
+    private final static int mExportReduceIdx_fz2 = 5;
     // in1 = "inVal"
     public result_int2 reduce_fz2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -423,11 +423,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_fz2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_fz2, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_histogram = 6;
+    private final static int mExportReduceIdx_histogram = 6;
     // in1 = "in"
     public resultArray256_uint reduce_histogram(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -456,11 +456,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32, 256);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_histogram, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_histogram, new Allocation[]{ain1}, aout, sc);
         return new resultArray256_uint(aout);
     }
 
-    private final static int mExportReduceNewIdx_mode = 7;
+    private final static int mExportReduceIdx_mode = 7;
     // in1 = "in"
     public result_int2 reduce_mode(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -489,7 +489,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_mode, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_mode, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
diff --git a/tests/P_reduce_general_examples_backward/ScriptC_reduce_general_examples_backward.java.expect b/tests/P_reduce_general_examples_backward/ScriptC_reduce_general_examples_backward.java.expect
index d71c7f8..50437f3 100644
--- a/tests/P_reduce_general_examples_backward/ScriptC_reduce_general_examples_backward.java.expect
+++ b/tests/P_reduce_general_examples_backward/ScriptC_reduce_general_examples_backward.java.expect
@@ -198,7 +198,7 @@
         private Int2 mResult;
     }
 
-    private final static int mExportReduceNewIdx_addint = 0;
+    private final static int mExportReduceIdx_addint = 0;
     // in1 = "val"
     public result_int reduce_addint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -227,11 +227,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_addint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_addint, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_mpyint = 1;
+    private final static int mExportReduceIdx_mpyint = 1;
     // in1 = "val"
     public result_int reduce_mpyint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -260,11 +260,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_mpyint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_mpyint, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_dp = 2;
+    private final static int mExportReduceIdx_dp = 2;
     // in1 = "in1"
     // in2 = "in2"
     public result_float reduce_dp(float[] in1, float[] in2) {
@@ -324,11 +324,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __F32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_dp, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_dp, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_float(aout);
     }
 
-    private final static int mExportReduceNewIdx_findMinAndMax = 3;
+    private final static int mExportReduceIdx_findMinAndMax = 3;
     // in1 = "in"
     public result_int2 reduce_findMinAndMax(float[] in1) {
         // Verify that "in1" is non-null.
@@ -357,11 +357,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_findMinAndMax, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_findMinAndMax, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_fz = 4;
+    private final static int mExportReduceIdx_fz = 4;
     // in1 = "inVal"
     public result_int reduce_fz(int[] in1) {
         // Verify that "in1" is non-null.
@@ -390,11 +390,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_fz, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_fz, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_fz2 = 5;
+    private final static int mExportReduceIdx_fz2 = 5;
     // in1 = "inVal"
     public result_int2 reduce_fz2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -423,11 +423,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_fz2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_fz2, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_histogram = 6;
+    private final static int mExportReduceIdx_histogram = 6;
     // in1 = "in"
     public resultArray256_uint reduce_histogram(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -456,11 +456,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32, 256);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_histogram, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_histogram, new Allocation[]{ain1}, aout, sc);
         return new resultArray256_uint(aout);
     }
 
-    private final static int mExportReduceNewIdx_mode = 7;
+    private final static int mExportReduceIdx_mode = 7;
     // in1 = "in"
     public result_int2 reduce_mode(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -489,7 +489,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_mode, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_mode, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
diff --git a/tests/P_reduce_general_examples_explicit/ScriptC_reduce_general_examples_explicit.java.expect b/tests/P_reduce_general_examples_explicit/ScriptC_reduce_general_examples_explicit.java.expect
index 6240645..013838e 100644
--- a/tests/P_reduce_general_examples_explicit/ScriptC_reduce_general_examples_explicit.java.expect
+++ b/tests/P_reduce_general_examples_explicit/ScriptC_reduce_general_examples_explicit.java.expect
@@ -160,7 +160,7 @@
         private int mResult;
     }
 
-    private final static int mExportReduceNewIdx_addint_init = 0;
+    private final static int mExportReduceIdx_addint_init = 0;
     // in1 = "val"
     public result_int reduce_addint_init(int[] in1) {
         // Verify that "in1" is non-null.
@@ -189,11 +189,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_addint_init, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_addint_init, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_addint_comb = 1;
+    private final static int mExportReduceIdx_addint_comb = 1;
     // in1 = "val"
     public result_int reduce_addint_comb(int[] in1) {
         // Verify that "in1" is non-null.
@@ -222,11 +222,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_addint_comb, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_addint_comb, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_addint_init_comb = 2;
+    private final static int mExportReduceIdx_addint_init_comb = 2;
     // in1 = "val"
     public result_int reduce_addint_init_comb(int[] in1) {
         // Verify that "in1" is non-null.
@@ -255,11 +255,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_addint_init_comb, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_addint_init_comb, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_dp_init = 3;
+    private final static int mExportReduceIdx_dp_init = 3;
     // in1 = "in1"
     // in2 = "in2"
     public result_float reduce_dp_init(float[] in1, float[] in2) {
@@ -319,11 +319,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __F32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_dp_init, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_dp_init, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_float(aout);
     }
 
-    private final static int mExportReduceNewIdx_histogram_init = 4;
+    private final static int mExportReduceIdx_histogram_init = 4;
     // in1 = "in"
     public resultArray256_uint reduce_histogram_init(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -352,7 +352,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32, 256);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_histogram_init, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_histogram_init, new Allocation[]{ain1}, aout, sc);
         return new resultArray256_uint(aout);
     }
 
diff --git a/tests/P_reduce_general_examples_halter/ScriptC_reduce_general_examples_halter.java.expect b/tests/P_reduce_general_examples_halter/ScriptC_reduce_general_examples_halter.java.expect
index 5d9ee49..0b2f3da 100644
--- a/tests/P_reduce_general_examples_halter/ScriptC_reduce_general_examples_halter.java.expect
+++ b/tests/P_reduce_general_examples_halter/ScriptC_reduce_general_examples_halter.java.expect
@@ -115,7 +115,7 @@
         private Int2 mResult;
     }
 
-    private final static int mExportReduceNewIdx_fz = 0;
+    private final static int mExportReduceIdx_fz = 0;
     // in1 = "inVal"
     public result_int reduce_fz(int[] in1) {
         // Verify that "in1" is non-null.
@@ -144,11 +144,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_fz, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_fz, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_fz2 = 1;
+    private final static int mExportReduceIdx_fz2 = 1;
     // in1 = "inVal"
     public result_int2 reduce_fz2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -177,7 +177,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_fz2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_fz2, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
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 48a9e6e..bc151f1 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
@@ -145,7 +145,7 @@
         private int mResult;
     }
 
-    private final static int mExportReduceNewIdx_my_half_0 = 0;
+    private final static int mExportReduceIdx_my_half_0 = 0;
     // in1 = "in"
     public result_int reduce_my_half_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -174,11 +174,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_1 = 1;
+    private final static int mExportReduceIdx_my_half_1 = 1;
     // in1 = "in"
     public result_int reduce_my_half_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -207,11 +207,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_2 = 2;
+    private final static int mExportReduceIdx_my_half_2 = 2;
     // in1 = "in"
     public result_int reduce_my_half_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -240,11 +240,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_3 = 3;
+    private final static int mExportReduceIdx_my_half_3 = 3;
     // in1 = "in"
     public result_int reduce_my_half_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -273,11 +273,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_4 = 4;
+    private final static int mExportReduceIdx_my_half_4 = 4;
     // in1 = "in"
     public result_int reduce_my_half_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -306,11 +306,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_5 = 5;
+    private final static int mExportReduceIdx_my_half_5 = 5;
     // in1 = "in"
     public result_int reduce_my_half_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -339,11 +339,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_6 = 6;
+    private final static int mExportReduceIdx_my_half_6 = 6;
     // in1 = "in"
     public result_int reduce_my_half_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -372,11 +372,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_7 = 7;
+    private final static int mExportReduceIdx_my_half_7 = 7;
     // in1 = "in"
     public result_int reduce_my_half_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -405,11 +405,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_8 = 8;
+    private final static int mExportReduceIdx_my_half_8 = 8;
     // in1 = "in"
     public result_int reduce_my_half_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -438,11 +438,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_9 = 9;
+    private final static int mExportReduceIdx_my_half_9 = 9;
     // in1 = "in"
     public result_int reduce_my_half_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -471,11 +471,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_10 = 10;
+    private final static int mExportReduceIdx_my_half_10 = 10;
     // in1 = "in"
     public result_int reduce_my_half_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -504,11 +504,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_11 = 11;
+    private final static int mExportReduceIdx_my_half_11 = 11;
     // in1 = "in"
     public result_int reduce_my_half_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -537,11 +537,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_12 = 12;
+    private final static int mExportReduceIdx_my_half_12 = 12;
     // in1 = "in"
     public result_int reduce_my_half_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -570,11 +570,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_13 = 13;
+    private final static int mExportReduceIdx_my_half_13 = 13;
     // in1 = "in"
     public result_int reduce_my_half_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -603,11 +603,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_14 = 14;
+    private final static int mExportReduceIdx_my_half_14 = 14;
     // in1 = "in"
     public result_int reduce_my_half_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -636,11 +636,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_15 = 15;
+    private final static int mExportReduceIdx_my_half_15 = 15;
     // in1 = "in"
     public result_int reduce_my_half_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -669,11 +669,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_0 = 16;
+    private final static int mExportReduceIdx_my_half2_0 = 16;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -706,11 +706,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_1 = 17;
+    private final static int mExportReduceIdx_my_half2_1 = 17;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -743,11 +743,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_2 = 18;
+    private final static int mExportReduceIdx_my_half2_2 = 18;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -780,11 +780,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_3 = 19;
+    private final static int mExportReduceIdx_my_half2_3 = 19;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -817,11 +817,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_4 = 20;
+    private final static int mExportReduceIdx_my_half2_4 = 20;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -854,11 +854,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_5 = 21;
+    private final static int mExportReduceIdx_my_half2_5 = 21;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -891,11 +891,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_6 = 22;
+    private final static int mExportReduceIdx_my_half2_6 = 22;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -928,11 +928,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_7 = 23;
+    private final static int mExportReduceIdx_my_half2_7 = 23;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -965,11 +965,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_8 = 24;
+    private final static int mExportReduceIdx_my_half2_8 = 24;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1002,11 +1002,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_9 = 25;
+    private final static int mExportReduceIdx_my_half2_9 = 25;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1039,11 +1039,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_10 = 26;
+    private final static int mExportReduceIdx_my_half2_10 = 26;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1076,11 +1076,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_11 = 27;
+    private final static int mExportReduceIdx_my_half2_11 = 27;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1113,11 +1113,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_12 = 28;
+    private final static int mExportReduceIdx_my_half2_12 = 28;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1150,11 +1150,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_13 = 29;
+    private final static int mExportReduceIdx_my_half2_13 = 29;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1187,11 +1187,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_14 = 30;
+    private final static int mExportReduceIdx_my_half2_14 = 30;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1224,11 +1224,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_15 = 31;
+    private final static int mExportReduceIdx_my_half2_15 = 31;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_half2_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1261,11 +1261,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_0 = 32;
+    private final static int mExportReduceIdx_my_half4_0 = 32;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1298,11 +1298,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_1 = 33;
+    private final static int mExportReduceIdx_my_half4_1 = 33;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1335,11 +1335,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_2 = 34;
+    private final static int mExportReduceIdx_my_half4_2 = 34;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1372,11 +1372,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_3 = 35;
+    private final static int mExportReduceIdx_my_half4_3 = 35;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1409,11 +1409,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_4 = 36;
+    private final static int mExportReduceIdx_my_half4_4 = 36;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1446,11 +1446,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_5 = 37;
+    private final static int mExportReduceIdx_my_half4_5 = 37;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1483,11 +1483,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_6 = 38;
+    private final static int mExportReduceIdx_my_half4_6 = 38;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1520,11 +1520,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_7 = 39;
+    private final static int mExportReduceIdx_my_half4_7 = 39;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1557,11 +1557,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_8 = 40;
+    private final static int mExportReduceIdx_my_half4_8 = 40;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1594,11 +1594,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_9 = 41;
+    private final static int mExportReduceIdx_my_half4_9 = 41;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1631,11 +1631,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_10 = 42;
+    private final static int mExportReduceIdx_my_half4_10 = 42;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1668,11 +1668,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_11 = 43;
+    private final static int mExportReduceIdx_my_half4_11 = 43;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1705,11 +1705,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_12 = 44;
+    private final static int mExportReduceIdx_my_half4_12 = 44;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1742,11 +1742,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_13 = 45;
+    private final static int mExportReduceIdx_my_half4_13 = 45;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1779,11 +1779,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_14 = 46;
+    private final static int mExportReduceIdx_my_half4_14 = 46;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1816,11 +1816,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_15 = 47;
+    private final static int mExportReduceIdx_my_half4_15 = 47;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_half4_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -1853,11 +1853,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_0 = 48;
+    private final static int mExportReduceIdx_my_float_0 = 48;
     // in1 = "in"
     public result_int reduce_my_float_0(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1886,11 +1886,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_1 = 49;
+    private final static int mExportReduceIdx_my_float_1 = 49;
     // in1 = "in"
     public result_int reduce_my_float_1(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1919,11 +1919,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_2 = 50;
+    private final static int mExportReduceIdx_my_float_2 = 50;
     // in1 = "in"
     public result_int reduce_my_float_2(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1952,11 +1952,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_3 = 51;
+    private final static int mExportReduceIdx_my_float_3 = 51;
     // in1 = "in"
     public result_int reduce_my_float_3(float[] in1) {
         // Verify that "in1" is non-null.
@@ -1985,11 +1985,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_4 = 52;
+    private final static int mExportReduceIdx_my_float_4 = 52;
     // in1 = "in"
     public result_int reduce_my_float_4(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2018,11 +2018,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_5 = 53;
+    private final static int mExportReduceIdx_my_float_5 = 53;
     // in1 = "in"
     public result_int reduce_my_float_5(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2051,11 +2051,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_6 = 54;
+    private final static int mExportReduceIdx_my_float_6 = 54;
     // in1 = "in"
     public result_int reduce_my_float_6(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2084,11 +2084,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_7 = 55;
+    private final static int mExportReduceIdx_my_float_7 = 55;
     // in1 = "in"
     public result_int reduce_my_float_7(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2117,11 +2117,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_8 = 56;
+    private final static int mExportReduceIdx_my_float_8 = 56;
     // in1 = "in"
     public result_int reduce_my_float_8(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2150,11 +2150,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_9 = 57;
+    private final static int mExportReduceIdx_my_float_9 = 57;
     // in1 = "in"
     public result_int reduce_my_float_9(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2183,11 +2183,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_10 = 58;
+    private final static int mExportReduceIdx_my_float_10 = 58;
     // in1 = "in"
     public result_int reduce_my_float_10(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2216,11 +2216,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_11 = 59;
+    private final static int mExportReduceIdx_my_float_11 = 59;
     // in1 = "in"
     public result_int reduce_my_float_11(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2249,11 +2249,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_12 = 60;
+    private final static int mExportReduceIdx_my_float_12 = 60;
     // in1 = "in"
     public result_int reduce_my_float_12(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2282,11 +2282,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_13 = 61;
+    private final static int mExportReduceIdx_my_float_13 = 61;
     // in1 = "in"
     public result_int reduce_my_float_13(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2315,11 +2315,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_14 = 62;
+    private final static int mExportReduceIdx_my_float_14 = 62;
     // in1 = "in"
     public result_int reduce_my_float_14(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2348,11 +2348,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_15 = 63;
+    private final static int mExportReduceIdx_my_float_15 = 63;
     // in1 = "in"
     public result_int reduce_my_float_15(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2381,11 +2381,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_0 = 64;
+    private final static int mExportReduceIdx_my_float2_0 = 64;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_0(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2418,11 +2418,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_1 = 65;
+    private final static int mExportReduceIdx_my_float2_1 = 65;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_1(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2455,11 +2455,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_2 = 66;
+    private final static int mExportReduceIdx_my_float2_2 = 66;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_2(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2492,11 +2492,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_3 = 67;
+    private final static int mExportReduceIdx_my_float2_3 = 67;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_3(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2529,11 +2529,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_4 = 68;
+    private final static int mExportReduceIdx_my_float2_4 = 68;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_4(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2566,11 +2566,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_5 = 69;
+    private final static int mExportReduceIdx_my_float2_5 = 69;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_5(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2603,11 +2603,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_6 = 70;
+    private final static int mExportReduceIdx_my_float2_6 = 70;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_6(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2640,11 +2640,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_7 = 71;
+    private final static int mExportReduceIdx_my_float2_7 = 71;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_7(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2677,11 +2677,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_8 = 72;
+    private final static int mExportReduceIdx_my_float2_8 = 72;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_8(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2714,11 +2714,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_9 = 73;
+    private final static int mExportReduceIdx_my_float2_9 = 73;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_9(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2751,11 +2751,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_10 = 74;
+    private final static int mExportReduceIdx_my_float2_10 = 74;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_10(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2788,11 +2788,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_11 = 75;
+    private final static int mExportReduceIdx_my_float2_11 = 75;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_11(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2825,11 +2825,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_12 = 76;
+    private final static int mExportReduceIdx_my_float2_12 = 76;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_12(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2862,11 +2862,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_13 = 77;
+    private final static int mExportReduceIdx_my_float2_13 = 77;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_13(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2899,11 +2899,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_14 = 78;
+    private final static int mExportReduceIdx_my_float2_14 = 78;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_14(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2936,11 +2936,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_15 = 79;
+    private final static int mExportReduceIdx_my_float2_15 = 79;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_float2_15(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2973,11 +2973,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_0 = 80;
+    private final static int mExportReduceIdx_my_float4_0 = 80;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_0(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3010,11 +3010,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_1 = 81;
+    private final static int mExportReduceIdx_my_float4_1 = 81;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_1(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3047,11 +3047,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_2 = 82;
+    private final static int mExportReduceIdx_my_float4_2 = 82;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_2(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3084,11 +3084,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_3 = 83;
+    private final static int mExportReduceIdx_my_float4_3 = 83;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_3(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3121,11 +3121,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_4 = 84;
+    private final static int mExportReduceIdx_my_float4_4 = 84;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_4(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3158,11 +3158,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_5 = 85;
+    private final static int mExportReduceIdx_my_float4_5 = 85;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_5(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3195,11 +3195,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_6 = 86;
+    private final static int mExportReduceIdx_my_float4_6 = 86;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_6(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3232,11 +3232,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_7 = 87;
+    private final static int mExportReduceIdx_my_float4_7 = 87;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_7(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3269,11 +3269,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_8 = 88;
+    private final static int mExportReduceIdx_my_float4_8 = 88;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_8(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3306,11 +3306,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_9 = 89;
+    private final static int mExportReduceIdx_my_float4_9 = 89;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_9(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3343,11 +3343,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_10 = 90;
+    private final static int mExportReduceIdx_my_float4_10 = 90;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_10(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3380,11 +3380,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_11 = 91;
+    private final static int mExportReduceIdx_my_float4_11 = 91;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_11(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3417,11 +3417,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_12 = 92;
+    private final static int mExportReduceIdx_my_float4_12 = 92;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_12(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3454,11 +3454,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_13 = 93;
+    private final static int mExportReduceIdx_my_float4_13 = 93;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_13(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3491,11 +3491,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_14 = 94;
+    private final static int mExportReduceIdx_my_float4_14 = 94;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_14(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3528,11 +3528,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_15 = 95;
+    private final static int mExportReduceIdx_my_float4_15 = 95;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_float4_15(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3565,11 +3565,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_0 = 96;
+    private final static int mExportReduceIdx_my_double_0 = 96;
     // in1 = "in"
     public result_int reduce_my_double_0(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3598,11 +3598,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_1 = 97;
+    private final static int mExportReduceIdx_my_double_1 = 97;
     // in1 = "in"
     public result_int reduce_my_double_1(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3631,11 +3631,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_2 = 98;
+    private final static int mExportReduceIdx_my_double_2 = 98;
     // in1 = "in"
     public result_int reduce_my_double_2(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3664,11 +3664,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_3 = 99;
+    private final static int mExportReduceIdx_my_double_3 = 99;
     // in1 = "in"
     public result_int reduce_my_double_3(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3697,11 +3697,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_4 = 100;
+    private final static int mExportReduceIdx_my_double_4 = 100;
     // in1 = "in"
     public result_int reduce_my_double_4(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3730,11 +3730,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_5 = 101;
+    private final static int mExportReduceIdx_my_double_5 = 101;
     // in1 = "in"
     public result_int reduce_my_double_5(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3763,11 +3763,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_6 = 102;
+    private final static int mExportReduceIdx_my_double_6 = 102;
     // in1 = "in"
     public result_int reduce_my_double_6(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3796,11 +3796,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_7 = 103;
+    private final static int mExportReduceIdx_my_double_7 = 103;
     // in1 = "in"
     public result_int reduce_my_double_7(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3829,11 +3829,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_8 = 104;
+    private final static int mExportReduceIdx_my_double_8 = 104;
     // in1 = "in"
     public result_int reduce_my_double_8(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3862,11 +3862,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_9 = 105;
+    private final static int mExportReduceIdx_my_double_9 = 105;
     // in1 = "in"
     public result_int reduce_my_double_9(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3895,11 +3895,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_10 = 106;
+    private final static int mExportReduceIdx_my_double_10 = 106;
     // in1 = "in"
     public result_int reduce_my_double_10(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3928,11 +3928,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_11 = 107;
+    private final static int mExportReduceIdx_my_double_11 = 107;
     // in1 = "in"
     public result_int reduce_my_double_11(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3961,11 +3961,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_12 = 108;
+    private final static int mExportReduceIdx_my_double_12 = 108;
     // in1 = "in"
     public result_int reduce_my_double_12(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3994,11 +3994,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_13 = 109;
+    private final static int mExportReduceIdx_my_double_13 = 109;
     // in1 = "in"
     public result_int reduce_my_double_13(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4027,11 +4027,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_14 = 110;
+    private final static int mExportReduceIdx_my_double_14 = 110;
     // in1 = "in"
     public result_int reduce_my_double_14(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4060,11 +4060,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double_15 = 111;
+    private final static int mExportReduceIdx_my_double_15 = 111;
     // in1 = "in"
     public result_int reduce_my_double_15(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4093,11 +4093,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_0 = 112;
+    private final static int mExportReduceIdx_my_double2_0 = 112;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_0(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4130,11 +4130,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_1 = 113;
+    private final static int mExportReduceIdx_my_double2_1 = 113;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_1(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4167,11 +4167,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_2 = 114;
+    private final static int mExportReduceIdx_my_double2_2 = 114;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_2(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4204,11 +4204,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_3 = 115;
+    private final static int mExportReduceIdx_my_double2_3 = 115;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_3(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4241,11 +4241,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_4 = 116;
+    private final static int mExportReduceIdx_my_double2_4 = 116;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_4(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4278,11 +4278,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_5 = 117;
+    private final static int mExportReduceIdx_my_double2_5 = 117;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_5(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4315,11 +4315,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_6 = 118;
+    private final static int mExportReduceIdx_my_double2_6 = 118;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_6(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4352,11 +4352,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_7 = 119;
+    private final static int mExportReduceIdx_my_double2_7 = 119;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_7(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4389,11 +4389,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_8 = 120;
+    private final static int mExportReduceIdx_my_double2_8 = 120;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_8(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4426,11 +4426,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_9 = 121;
+    private final static int mExportReduceIdx_my_double2_9 = 121;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_9(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4463,11 +4463,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_10 = 122;
+    private final static int mExportReduceIdx_my_double2_10 = 122;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_10(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4500,11 +4500,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_11 = 123;
+    private final static int mExportReduceIdx_my_double2_11 = 123;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_11(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4537,11 +4537,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_12 = 124;
+    private final static int mExportReduceIdx_my_double2_12 = 124;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_12(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4574,11 +4574,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_13 = 125;
+    private final static int mExportReduceIdx_my_double2_13 = 125;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_13(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4611,11 +4611,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_14 = 126;
+    private final static int mExportReduceIdx_my_double2_14 = 126;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_14(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4648,11 +4648,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2_15 = 127;
+    private final static int mExportReduceIdx_my_double2_15 = 127;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_double2_15(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4685,11 +4685,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_0 = 128;
+    private final static int mExportReduceIdx_my_double4_0 = 128;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_0(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4722,11 +4722,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_1 = 129;
+    private final static int mExportReduceIdx_my_double4_1 = 129;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_1(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4759,11 +4759,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_2 = 130;
+    private final static int mExportReduceIdx_my_double4_2 = 130;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_2(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4796,11 +4796,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_3 = 131;
+    private final static int mExportReduceIdx_my_double4_3 = 131;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_3(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4833,11 +4833,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_4 = 132;
+    private final static int mExportReduceIdx_my_double4_4 = 132;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_4(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4870,11 +4870,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_5 = 133;
+    private final static int mExportReduceIdx_my_double4_5 = 133;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_5(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4907,11 +4907,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_6 = 134;
+    private final static int mExportReduceIdx_my_double4_6 = 134;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_6(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4944,11 +4944,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_7 = 135;
+    private final static int mExportReduceIdx_my_double4_7 = 135;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_7(double[] in1) {
         // Verify that "in1" is non-null.
@@ -4981,11 +4981,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_8 = 136;
+    private final static int mExportReduceIdx_my_double4_8 = 136;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_8(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5018,11 +5018,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_9 = 137;
+    private final static int mExportReduceIdx_my_double4_9 = 137;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_9(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5055,11 +5055,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_10 = 138;
+    private final static int mExportReduceIdx_my_double4_10 = 138;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_10(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5092,11 +5092,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_11 = 139;
+    private final static int mExportReduceIdx_my_double4_11 = 139;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_11(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5129,11 +5129,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_12 = 140;
+    private final static int mExportReduceIdx_my_double4_12 = 140;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_12(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5166,11 +5166,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_13 = 141;
+    private final static int mExportReduceIdx_my_double4_13 = 141;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_13(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5203,11 +5203,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_14 = 142;
+    private final static int mExportReduceIdx_my_double4_14 = 142;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_14(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5240,11 +5240,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4_15 = 143;
+    private final static int mExportReduceIdx_my_double4_15 = 143;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_double4_15(double[] in1) {
         // Verify that "in1" is non-null.
@@ -5277,11 +5277,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_0 = 144;
+    private final static int mExportReduceIdx_my_char_0 = 144;
     // in1 = "in"
     public result_int reduce_my_char_0(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5310,11 +5310,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_1 = 145;
+    private final static int mExportReduceIdx_my_char_1 = 145;
     // in1 = "in"
     public result_int reduce_my_char_1(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5343,11 +5343,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_2 = 146;
+    private final static int mExportReduceIdx_my_char_2 = 146;
     // in1 = "in"
     public result_int reduce_my_char_2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5376,11 +5376,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_3 = 147;
+    private final static int mExportReduceIdx_my_char_3 = 147;
     // in1 = "in"
     public result_int reduce_my_char_3(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5409,11 +5409,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_4 = 148;
+    private final static int mExportReduceIdx_my_char_4 = 148;
     // in1 = "in"
     public result_int reduce_my_char_4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5442,11 +5442,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_5 = 149;
+    private final static int mExportReduceIdx_my_char_5 = 149;
     // in1 = "in"
     public result_int reduce_my_char_5(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5475,11 +5475,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_6 = 150;
+    private final static int mExportReduceIdx_my_char_6 = 150;
     // in1 = "in"
     public result_int reduce_my_char_6(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5508,11 +5508,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_7 = 151;
+    private final static int mExportReduceIdx_my_char_7 = 151;
     // in1 = "in"
     public result_int reduce_my_char_7(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5541,11 +5541,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_8 = 152;
+    private final static int mExportReduceIdx_my_char_8 = 152;
     // in1 = "in"
     public result_int reduce_my_char_8(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5574,11 +5574,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_9 = 153;
+    private final static int mExportReduceIdx_my_char_9 = 153;
     // in1 = "in"
     public result_int reduce_my_char_9(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5607,11 +5607,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_10 = 154;
+    private final static int mExportReduceIdx_my_char_10 = 154;
     // in1 = "in"
     public result_int reduce_my_char_10(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5640,11 +5640,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_11 = 155;
+    private final static int mExportReduceIdx_my_char_11 = 155;
     // in1 = "in"
     public result_int reduce_my_char_11(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5673,11 +5673,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_12 = 156;
+    private final static int mExportReduceIdx_my_char_12 = 156;
     // in1 = "in"
     public result_int reduce_my_char_12(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5706,11 +5706,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_13 = 157;
+    private final static int mExportReduceIdx_my_char_13 = 157;
     // in1 = "in"
     public result_int reduce_my_char_13(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5739,11 +5739,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_14 = 158;
+    private final static int mExportReduceIdx_my_char_14 = 158;
     // in1 = "in"
     public result_int reduce_my_char_14(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5772,11 +5772,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_15 = 159;
+    private final static int mExportReduceIdx_my_char_15 = 159;
     // in1 = "in"
     public result_int reduce_my_char_15(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5805,11 +5805,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_0 = 160;
+    private final static int mExportReduceIdx_my_char2_0 = 160;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_0(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5842,11 +5842,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_1 = 161;
+    private final static int mExportReduceIdx_my_char2_1 = 161;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_1(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5879,11 +5879,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_2 = 162;
+    private final static int mExportReduceIdx_my_char2_2 = 162;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5916,11 +5916,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_3 = 163;
+    private final static int mExportReduceIdx_my_char2_3 = 163;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_3(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5953,11 +5953,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_4 = 164;
+    private final static int mExportReduceIdx_my_char2_4 = 164;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5990,11 +5990,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_5 = 165;
+    private final static int mExportReduceIdx_my_char2_5 = 165;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_5(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6027,11 +6027,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_6 = 166;
+    private final static int mExportReduceIdx_my_char2_6 = 166;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_6(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6064,11 +6064,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_7 = 167;
+    private final static int mExportReduceIdx_my_char2_7 = 167;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_7(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6101,11 +6101,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_8 = 168;
+    private final static int mExportReduceIdx_my_char2_8 = 168;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_8(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6138,11 +6138,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_9 = 169;
+    private final static int mExportReduceIdx_my_char2_9 = 169;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_9(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6175,11 +6175,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_10 = 170;
+    private final static int mExportReduceIdx_my_char2_10 = 170;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_10(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6212,11 +6212,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_11 = 171;
+    private final static int mExportReduceIdx_my_char2_11 = 171;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_11(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6249,11 +6249,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_12 = 172;
+    private final static int mExportReduceIdx_my_char2_12 = 172;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_12(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6286,11 +6286,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_13 = 173;
+    private final static int mExportReduceIdx_my_char2_13 = 173;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_13(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6323,11 +6323,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_14 = 174;
+    private final static int mExportReduceIdx_my_char2_14 = 174;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_14(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6360,11 +6360,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_15 = 175;
+    private final static int mExportReduceIdx_my_char2_15 = 175;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_char2_15(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6397,11 +6397,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_0 = 176;
+    private final static int mExportReduceIdx_my_char4_0 = 176;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_0(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6434,11 +6434,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_1 = 177;
+    private final static int mExportReduceIdx_my_char4_1 = 177;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_1(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6471,11 +6471,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_2 = 178;
+    private final static int mExportReduceIdx_my_char4_2 = 178;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6508,11 +6508,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_3 = 179;
+    private final static int mExportReduceIdx_my_char4_3 = 179;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_3(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6545,11 +6545,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_4 = 180;
+    private final static int mExportReduceIdx_my_char4_4 = 180;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6582,11 +6582,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_5 = 181;
+    private final static int mExportReduceIdx_my_char4_5 = 181;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_5(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6619,11 +6619,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_6 = 182;
+    private final static int mExportReduceIdx_my_char4_6 = 182;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_6(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6656,11 +6656,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_7 = 183;
+    private final static int mExportReduceIdx_my_char4_7 = 183;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_7(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6693,11 +6693,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_8 = 184;
+    private final static int mExportReduceIdx_my_char4_8 = 184;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_8(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6730,11 +6730,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_9 = 185;
+    private final static int mExportReduceIdx_my_char4_9 = 185;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_9(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6767,11 +6767,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_10 = 186;
+    private final static int mExportReduceIdx_my_char4_10 = 186;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_10(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6804,11 +6804,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_11 = 187;
+    private final static int mExportReduceIdx_my_char4_11 = 187;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_11(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6841,11 +6841,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_12 = 188;
+    private final static int mExportReduceIdx_my_char4_12 = 188;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_12(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6878,11 +6878,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_13 = 189;
+    private final static int mExportReduceIdx_my_char4_13 = 189;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_13(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6915,11 +6915,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_14 = 190;
+    private final static int mExportReduceIdx_my_char4_14 = 190;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_14(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6952,11 +6952,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_15 = 191;
+    private final static int mExportReduceIdx_my_char4_15 = 191;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_char4_15(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -6989,11 +6989,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_0 = 192;
+    private final static int mExportReduceIdx_my_short_0 = 192;
     // in1 = "in"
     public result_int reduce_my_short_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7022,11 +7022,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_1 = 193;
+    private final static int mExportReduceIdx_my_short_1 = 193;
     // in1 = "in"
     public result_int reduce_my_short_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7055,11 +7055,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_2 = 194;
+    private final static int mExportReduceIdx_my_short_2 = 194;
     // in1 = "in"
     public result_int reduce_my_short_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7088,11 +7088,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_3 = 195;
+    private final static int mExportReduceIdx_my_short_3 = 195;
     // in1 = "in"
     public result_int reduce_my_short_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7121,11 +7121,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_4 = 196;
+    private final static int mExportReduceIdx_my_short_4 = 196;
     // in1 = "in"
     public result_int reduce_my_short_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7154,11 +7154,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_5 = 197;
+    private final static int mExportReduceIdx_my_short_5 = 197;
     // in1 = "in"
     public result_int reduce_my_short_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7187,11 +7187,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_6 = 198;
+    private final static int mExportReduceIdx_my_short_6 = 198;
     // in1 = "in"
     public result_int reduce_my_short_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7220,11 +7220,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_7 = 199;
+    private final static int mExportReduceIdx_my_short_7 = 199;
     // in1 = "in"
     public result_int reduce_my_short_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7253,11 +7253,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_8 = 200;
+    private final static int mExportReduceIdx_my_short_8 = 200;
     // in1 = "in"
     public result_int reduce_my_short_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7286,11 +7286,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_9 = 201;
+    private final static int mExportReduceIdx_my_short_9 = 201;
     // in1 = "in"
     public result_int reduce_my_short_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7319,11 +7319,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_10 = 202;
+    private final static int mExportReduceIdx_my_short_10 = 202;
     // in1 = "in"
     public result_int reduce_my_short_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7352,11 +7352,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_11 = 203;
+    private final static int mExportReduceIdx_my_short_11 = 203;
     // in1 = "in"
     public result_int reduce_my_short_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7385,11 +7385,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_12 = 204;
+    private final static int mExportReduceIdx_my_short_12 = 204;
     // in1 = "in"
     public result_int reduce_my_short_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7418,11 +7418,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_13 = 205;
+    private final static int mExportReduceIdx_my_short_13 = 205;
     // in1 = "in"
     public result_int reduce_my_short_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7451,11 +7451,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_14 = 206;
+    private final static int mExportReduceIdx_my_short_14 = 206;
     // in1 = "in"
     public result_int reduce_my_short_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7484,11 +7484,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_15 = 207;
+    private final static int mExportReduceIdx_my_short_15 = 207;
     // in1 = "in"
     public result_int reduce_my_short_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7517,11 +7517,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_0 = 208;
+    private final static int mExportReduceIdx_my_short2_0 = 208;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7554,11 +7554,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_1 = 209;
+    private final static int mExportReduceIdx_my_short2_1 = 209;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7591,11 +7591,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_2 = 210;
+    private final static int mExportReduceIdx_my_short2_2 = 210;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7628,11 +7628,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_3 = 211;
+    private final static int mExportReduceIdx_my_short2_3 = 211;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7665,11 +7665,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_4 = 212;
+    private final static int mExportReduceIdx_my_short2_4 = 212;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7702,11 +7702,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_5 = 213;
+    private final static int mExportReduceIdx_my_short2_5 = 213;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7739,11 +7739,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_6 = 214;
+    private final static int mExportReduceIdx_my_short2_6 = 214;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7776,11 +7776,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_7 = 215;
+    private final static int mExportReduceIdx_my_short2_7 = 215;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7813,11 +7813,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_8 = 216;
+    private final static int mExportReduceIdx_my_short2_8 = 216;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7850,11 +7850,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_9 = 217;
+    private final static int mExportReduceIdx_my_short2_9 = 217;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7887,11 +7887,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_10 = 218;
+    private final static int mExportReduceIdx_my_short2_10 = 218;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7924,11 +7924,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_11 = 219;
+    private final static int mExportReduceIdx_my_short2_11 = 219;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7961,11 +7961,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_12 = 220;
+    private final static int mExportReduceIdx_my_short2_12 = 220;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -7998,11 +7998,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_13 = 221;
+    private final static int mExportReduceIdx_my_short2_13 = 221;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8035,11 +8035,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_14 = 222;
+    private final static int mExportReduceIdx_my_short2_14 = 222;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8072,11 +8072,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_15 = 223;
+    private final static int mExportReduceIdx_my_short2_15 = 223;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_short2_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8109,11 +8109,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_0 = 224;
+    private final static int mExportReduceIdx_my_short4_0 = 224;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8146,11 +8146,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_1 = 225;
+    private final static int mExportReduceIdx_my_short4_1 = 225;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8183,11 +8183,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_2 = 226;
+    private final static int mExportReduceIdx_my_short4_2 = 226;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8220,11 +8220,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_3 = 227;
+    private final static int mExportReduceIdx_my_short4_3 = 227;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8257,11 +8257,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_4 = 228;
+    private final static int mExportReduceIdx_my_short4_4 = 228;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8294,11 +8294,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_5 = 229;
+    private final static int mExportReduceIdx_my_short4_5 = 229;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8331,11 +8331,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_6 = 230;
+    private final static int mExportReduceIdx_my_short4_6 = 230;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8368,11 +8368,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_7 = 231;
+    private final static int mExportReduceIdx_my_short4_7 = 231;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8405,11 +8405,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_8 = 232;
+    private final static int mExportReduceIdx_my_short4_8 = 232;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8442,11 +8442,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_9 = 233;
+    private final static int mExportReduceIdx_my_short4_9 = 233;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8479,11 +8479,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_10 = 234;
+    private final static int mExportReduceIdx_my_short4_10 = 234;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8516,11 +8516,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_11 = 235;
+    private final static int mExportReduceIdx_my_short4_11 = 235;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8553,11 +8553,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_12 = 236;
+    private final static int mExportReduceIdx_my_short4_12 = 236;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8590,11 +8590,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_13 = 237;
+    private final static int mExportReduceIdx_my_short4_13 = 237;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8627,11 +8627,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_14 = 238;
+    private final static int mExportReduceIdx_my_short4_14 = 238;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8664,11 +8664,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_15 = 239;
+    private final static int mExportReduceIdx_my_short4_15 = 239;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_short4_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -8701,11 +8701,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_0 = 240;
+    private final static int mExportReduceIdx_my_int_0 = 240;
     // in1 = "in"
     public result_int reduce_my_int_0(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8734,11 +8734,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_1 = 241;
+    private final static int mExportReduceIdx_my_int_1 = 241;
     // in1 = "in"
     public result_int reduce_my_int_1(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8767,11 +8767,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_2 = 242;
+    private final static int mExportReduceIdx_my_int_2 = 242;
     // in1 = "in"
     public result_int reduce_my_int_2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8800,11 +8800,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_3 = 243;
+    private final static int mExportReduceIdx_my_int_3 = 243;
     // in1 = "in"
     public result_int reduce_my_int_3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8833,11 +8833,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_4 = 244;
+    private final static int mExportReduceIdx_my_int_4 = 244;
     // in1 = "in"
     public result_int reduce_my_int_4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8866,11 +8866,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_5 = 245;
+    private final static int mExportReduceIdx_my_int_5 = 245;
     // in1 = "in"
     public result_int reduce_my_int_5(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8899,11 +8899,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_6 = 246;
+    private final static int mExportReduceIdx_my_int_6 = 246;
     // in1 = "in"
     public result_int reduce_my_int_6(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8932,11 +8932,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_7 = 247;
+    private final static int mExportReduceIdx_my_int_7 = 247;
     // in1 = "in"
     public result_int reduce_my_int_7(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8965,11 +8965,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_8 = 248;
+    private final static int mExportReduceIdx_my_int_8 = 248;
     // in1 = "in"
     public result_int reduce_my_int_8(int[] in1) {
         // Verify that "in1" is non-null.
@@ -8998,11 +8998,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_9 = 249;
+    private final static int mExportReduceIdx_my_int_9 = 249;
     // in1 = "in"
     public result_int reduce_my_int_9(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9031,11 +9031,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_10 = 250;
+    private final static int mExportReduceIdx_my_int_10 = 250;
     // in1 = "in"
     public result_int reduce_my_int_10(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9064,11 +9064,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_11 = 251;
+    private final static int mExportReduceIdx_my_int_11 = 251;
     // in1 = "in"
     public result_int reduce_my_int_11(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9097,11 +9097,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_12 = 252;
+    private final static int mExportReduceIdx_my_int_12 = 252;
     // in1 = "in"
     public result_int reduce_my_int_12(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9130,11 +9130,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_13 = 253;
+    private final static int mExportReduceIdx_my_int_13 = 253;
     // in1 = "in"
     public result_int reduce_my_int_13(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9163,11 +9163,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_14 = 254;
+    private final static int mExportReduceIdx_my_int_14 = 254;
     // in1 = "in"
     public result_int reduce_my_int_14(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9196,11 +9196,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int_15 = 255;
+    private final static int mExportReduceIdx_my_int_15 = 255;
     // in1 = "in"
     public result_int reduce_my_int_15(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9229,11 +9229,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_0 = 256;
+    private final static int mExportReduceIdx_my_int2_0 = 256;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_0(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9266,11 +9266,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_1 = 257;
+    private final static int mExportReduceIdx_my_int2_1 = 257;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_1(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9303,11 +9303,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_2 = 258;
+    private final static int mExportReduceIdx_my_int2_2 = 258;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9340,11 +9340,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_3 = 259;
+    private final static int mExportReduceIdx_my_int2_3 = 259;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9377,11 +9377,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_4 = 260;
+    private final static int mExportReduceIdx_my_int2_4 = 260;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9414,11 +9414,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_5 = 261;
+    private final static int mExportReduceIdx_my_int2_5 = 261;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_5(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9451,11 +9451,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_6 = 262;
+    private final static int mExportReduceIdx_my_int2_6 = 262;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_6(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9488,11 +9488,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_7 = 263;
+    private final static int mExportReduceIdx_my_int2_7 = 263;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_7(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9525,11 +9525,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_8 = 264;
+    private final static int mExportReduceIdx_my_int2_8 = 264;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_8(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9562,11 +9562,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_9 = 265;
+    private final static int mExportReduceIdx_my_int2_9 = 265;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_9(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9599,11 +9599,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_10 = 266;
+    private final static int mExportReduceIdx_my_int2_10 = 266;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_10(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9636,11 +9636,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_11 = 267;
+    private final static int mExportReduceIdx_my_int2_11 = 267;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_11(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9673,11 +9673,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_12 = 268;
+    private final static int mExportReduceIdx_my_int2_12 = 268;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_12(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9710,11 +9710,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_13 = 269;
+    private final static int mExportReduceIdx_my_int2_13 = 269;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_13(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9747,11 +9747,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_14 = 270;
+    private final static int mExportReduceIdx_my_int2_14 = 270;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_14(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9784,11 +9784,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2_15 = 271;
+    private final static int mExportReduceIdx_my_int2_15 = 271;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_int2_15(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9821,11 +9821,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_0 = 272;
+    private final static int mExportReduceIdx_my_int4_0 = 272;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_0(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9858,11 +9858,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_1 = 273;
+    private final static int mExportReduceIdx_my_int4_1 = 273;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_1(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9895,11 +9895,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_2 = 274;
+    private final static int mExportReduceIdx_my_int4_2 = 274;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9932,11 +9932,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_3 = 275;
+    private final static int mExportReduceIdx_my_int4_3 = 275;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -9969,11 +9969,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_4 = 276;
+    private final static int mExportReduceIdx_my_int4_4 = 276;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10006,11 +10006,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_5 = 277;
+    private final static int mExportReduceIdx_my_int4_5 = 277;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_5(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10043,11 +10043,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_6 = 278;
+    private final static int mExportReduceIdx_my_int4_6 = 278;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_6(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10080,11 +10080,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_7 = 279;
+    private final static int mExportReduceIdx_my_int4_7 = 279;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_7(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10117,11 +10117,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_8 = 280;
+    private final static int mExportReduceIdx_my_int4_8 = 280;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_8(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10154,11 +10154,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_9 = 281;
+    private final static int mExportReduceIdx_my_int4_9 = 281;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_9(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10191,11 +10191,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_10 = 282;
+    private final static int mExportReduceIdx_my_int4_10 = 282;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_10(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10228,11 +10228,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_11 = 283;
+    private final static int mExportReduceIdx_my_int4_11 = 283;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_11(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10265,11 +10265,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_12 = 284;
+    private final static int mExportReduceIdx_my_int4_12 = 284;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_12(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10302,11 +10302,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_13 = 285;
+    private final static int mExportReduceIdx_my_int4_13 = 285;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_13(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10339,11 +10339,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_14 = 286;
+    private final static int mExportReduceIdx_my_int4_14 = 286;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_14(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10376,11 +10376,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4_15 = 287;
+    private final static int mExportReduceIdx_my_int4_15 = 287;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_int4_15(int[] in1) {
         // Verify that "in1" is non-null.
@@ -10413,11 +10413,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_0 = 288;
+    private final static int mExportReduceIdx_my_long_0 = 288;
     // in1 = "in"
     public result_int reduce_my_long_0(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10446,11 +10446,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_1 = 289;
+    private final static int mExportReduceIdx_my_long_1 = 289;
     // in1 = "in"
     public result_int reduce_my_long_1(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10479,11 +10479,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_2 = 290;
+    private final static int mExportReduceIdx_my_long_2 = 290;
     // in1 = "in"
     public result_int reduce_my_long_2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10512,11 +10512,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_3 = 291;
+    private final static int mExportReduceIdx_my_long_3 = 291;
     // in1 = "in"
     public result_int reduce_my_long_3(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10545,11 +10545,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_4 = 292;
+    private final static int mExportReduceIdx_my_long_4 = 292;
     // in1 = "in"
     public result_int reduce_my_long_4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10578,11 +10578,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_5 = 293;
+    private final static int mExportReduceIdx_my_long_5 = 293;
     // in1 = "in"
     public result_int reduce_my_long_5(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10611,11 +10611,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_6 = 294;
+    private final static int mExportReduceIdx_my_long_6 = 294;
     // in1 = "in"
     public result_int reduce_my_long_6(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10644,11 +10644,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_7 = 295;
+    private final static int mExportReduceIdx_my_long_7 = 295;
     // in1 = "in"
     public result_int reduce_my_long_7(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10677,11 +10677,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_8 = 296;
+    private final static int mExportReduceIdx_my_long_8 = 296;
     // in1 = "in"
     public result_int reduce_my_long_8(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10710,11 +10710,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_9 = 297;
+    private final static int mExportReduceIdx_my_long_9 = 297;
     // in1 = "in"
     public result_int reduce_my_long_9(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10743,11 +10743,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_10 = 298;
+    private final static int mExportReduceIdx_my_long_10 = 298;
     // in1 = "in"
     public result_int reduce_my_long_10(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10776,11 +10776,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_11 = 299;
+    private final static int mExportReduceIdx_my_long_11 = 299;
     // in1 = "in"
     public result_int reduce_my_long_11(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10809,11 +10809,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_12 = 300;
+    private final static int mExportReduceIdx_my_long_12 = 300;
     // in1 = "in"
     public result_int reduce_my_long_12(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10842,11 +10842,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_13 = 301;
+    private final static int mExportReduceIdx_my_long_13 = 301;
     // in1 = "in"
     public result_int reduce_my_long_13(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10875,11 +10875,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_14 = 302;
+    private final static int mExportReduceIdx_my_long_14 = 302;
     // in1 = "in"
     public result_int reduce_my_long_14(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10908,11 +10908,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long_15 = 303;
+    private final static int mExportReduceIdx_my_long_15 = 303;
     // in1 = "in"
     public result_int reduce_my_long_15(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10941,11 +10941,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_0 = 304;
+    private final static int mExportReduceIdx_my_long2_0 = 304;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_0(long[] in1) {
         // Verify that "in1" is non-null.
@@ -10978,11 +10978,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_1 = 305;
+    private final static int mExportReduceIdx_my_long2_1 = 305;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_1(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11015,11 +11015,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_2 = 306;
+    private final static int mExportReduceIdx_my_long2_2 = 306;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11052,11 +11052,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_3 = 307;
+    private final static int mExportReduceIdx_my_long2_3 = 307;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_3(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11089,11 +11089,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_4 = 308;
+    private final static int mExportReduceIdx_my_long2_4 = 308;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11126,11 +11126,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_5 = 309;
+    private final static int mExportReduceIdx_my_long2_5 = 309;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_5(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11163,11 +11163,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_6 = 310;
+    private final static int mExportReduceIdx_my_long2_6 = 310;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_6(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11200,11 +11200,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_7 = 311;
+    private final static int mExportReduceIdx_my_long2_7 = 311;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_7(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11237,11 +11237,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_8 = 312;
+    private final static int mExportReduceIdx_my_long2_8 = 312;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_8(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11274,11 +11274,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_9 = 313;
+    private final static int mExportReduceIdx_my_long2_9 = 313;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_9(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11311,11 +11311,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_10 = 314;
+    private final static int mExportReduceIdx_my_long2_10 = 314;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_10(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11348,11 +11348,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_11 = 315;
+    private final static int mExportReduceIdx_my_long2_11 = 315;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_11(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11385,11 +11385,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_12 = 316;
+    private final static int mExportReduceIdx_my_long2_12 = 316;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_12(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11422,11 +11422,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_13 = 317;
+    private final static int mExportReduceIdx_my_long2_13 = 317;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_13(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11459,11 +11459,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_14 = 318;
+    private final static int mExportReduceIdx_my_long2_14 = 318;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_14(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11496,11 +11496,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2_15 = 319;
+    private final static int mExportReduceIdx_my_long2_15 = 319;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_long2_15(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11533,11 +11533,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_0 = 320;
+    private final static int mExportReduceIdx_my_long4_0 = 320;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_0(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11570,11 +11570,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_1 = 321;
+    private final static int mExportReduceIdx_my_long4_1 = 321;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_1(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11607,11 +11607,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_2 = 322;
+    private final static int mExportReduceIdx_my_long4_2 = 322;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11644,11 +11644,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_3 = 323;
+    private final static int mExportReduceIdx_my_long4_3 = 323;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_3(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11681,11 +11681,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_4 = 324;
+    private final static int mExportReduceIdx_my_long4_4 = 324;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11718,11 +11718,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_5 = 325;
+    private final static int mExportReduceIdx_my_long4_5 = 325;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_5(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11755,11 +11755,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_6 = 326;
+    private final static int mExportReduceIdx_my_long4_6 = 326;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_6(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11792,11 +11792,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_7 = 327;
+    private final static int mExportReduceIdx_my_long4_7 = 327;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_7(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11829,11 +11829,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_8 = 328;
+    private final static int mExportReduceIdx_my_long4_8 = 328;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_8(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11866,11 +11866,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_9 = 329;
+    private final static int mExportReduceIdx_my_long4_9 = 329;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_9(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11903,11 +11903,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_10 = 330;
+    private final static int mExportReduceIdx_my_long4_10 = 330;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_10(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11940,11 +11940,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_11 = 331;
+    private final static int mExportReduceIdx_my_long4_11 = 331;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_11(long[] in1) {
         // Verify that "in1" is non-null.
@@ -11977,11 +11977,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_12 = 332;
+    private final static int mExportReduceIdx_my_long4_12 = 332;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_12(long[] in1) {
         // Verify that "in1" is non-null.
@@ -12014,11 +12014,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_13 = 333;
+    private final static int mExportReduceIdx_my_long4_13 = 333;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_13(long[] in1) {
         // Verify that "in1" is non-null.
@@ -12051,11 +12051,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_14 = 334;
+    private final static int mExportReduceIdx_my_long4_14 = 334;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_14(long[] in1) {
         // Verify that "in1" is non-null.
@@ -12088,11 +12088,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4_15 = 335;
+    private final static int mExportReduceIdx_my_long4_15 = 335;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_long4_15(long[] in1) {
         // Verify that "in1" is non-null.
@@ -12125,11 +12125,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_0 = 336;
+    private final static int mExportReduceIdx_my_uchar_0 = 336;
     // in1 = "in"
     public result_int reduce_my_uchar_0(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12158,11 +12158,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_1 = 337;
+    private final static int mExportReduceIdx_my_uchar_1 = 337;
     // in1 = "in"
     public result_int reduce_my_uchar_1(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12191,11 +12191,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_2 = 338;
+    private final static int mExportReduceIdx_my_uchar_2 = 338;
     // in1 = "in"
     public result_int reduce_my_uchar_2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12224,11 +12224,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_3 = 339;
+    private final static int mExportReduceIdx_my_uchar_3 = 339;
     // in1 = "in"
     public result_int reduce_my_uchar_3(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12257,11 +12257,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_4 = 340;
+    private final static int mExportReduceIdx_my_uchar_4 = 340;
     // in1 = "in"
     public result_int reduce_my_uchar_4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12290,11 +12290,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_5 = 341;
+    private final static int mExportReduceIdx_my_uchar_5 = 341;
     // in1 = "in"
     public result_int reduce_my_uchar_5(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12323,11 +12323,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_6 = 342;
+    private final static int mExportReduceIdx_my_uchar_6 = 342;
     // in1 = "in"
     public result_int reduce_my_uchar_6(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12356,11 +12356,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_7 = 343;
+    private final static int mExportReduceIdx_my_uchar_7 = 343;
     // in1 = "in"
     public result_int reduce_my_uchar_7(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12389,11 +12389,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_8 = 344;
+    private final static int mExportReduceIdx_my_uchar_8 = 344;
     // in1 = "in"
     public result_int reduce_my_uchar_8(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12422,11 +12422,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_9 = 345;
+    private final static int mExportReduceIdx_my_uchar_9 = 345;
     // in1 = "in"
     public result_int reduce_my_uchar_9(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12455,11 +12455,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_10 = 346;
+    private final static int mExportReduceIdx_my_uchar_10 = 346;
     // in1 = "in"
     public result_int reduce_my_uchar_10(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12488,11 +12488,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_11 = 347;
+    private final static int mExportReduceIdx_my_uchar_11 = 347;
     // in1 = "in"
     public result_int reduce_my_uchar_11(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12521,11 +12521,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_12 = 348;
+    private final static int mExportReduceIdx_my_uchar_12 = 348;
     // in1 = "in"
     public result_int reduce_my_uchar_12(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12554,11 +12554,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_13 = 349;
+    private final static int mExportReduceIdx_my_uchar_13 = 349;
     // in1 = "in"
     public result_int reduce_my_uchar_13(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12587,11 +12587,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_14 = 350;
+    private final static int mExportReduceIdx_my_uchar_14 = 350;
     // in1 = "in"
     public result_int reduce_my_uchar_14(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12620,11 +12620,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_15 = 351;
+    private final static int mExportReduceIdx_my_uchar_15 = 351;
     // in1 = "in"
     public result_int reduce_my_uchar_15(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12653,11 +12653,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_0 = 352;
+    private final static int mExportReduceIdx_my_uchar2_0 = 352;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_0(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12690,11 +12690,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_1 = 353;
+    private final static int mExportReduceIdx_my_uchar2_1 = 353;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_1(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12727,11 +12727,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_2 = 354;
+    private final static int mExportReduceIdx_my_uchar2_2 = 354;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12764,11 +12764,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_3 = 355;
+    private final static int mExportReduceIdx_my_uchar2_3 = 355;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_3(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12801,11 +12801,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_4 = 356;
+    private final static int mExportReduceIdx_my_uchar2_4 = 356;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12838,11 +12838,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_5 = 357;
+    private final static int mExportReduceIdx_my_uchar2_5 = 357;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_5(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12875,11 +12875,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_6 = 358;
+    private final static int mExportReduceIdx_my_uchar2_6 = 358;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_6(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12912,11 +12912,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_7 = 359;
+    private final static int mExportReduceIdx_my_uchar2_7 = 359;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_7(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12949,11 +12949,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_8 = 360;
+    private final static int mExportReduceIdx_my_uchar2_8 = 360;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_8(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -12986,11 +12986,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_9 = 361;
+    private final static int mExportReduceIdx_my_uchar2_9 = 361;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_9(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13023,11 +13023,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_10 = 362;
+    private final static int mExportReduceIdx_my_uchar2_10 = 362;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_10(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13060,11 +13060,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_11 = 363;
+    private final static int mExportReduceIdx_my_uchar2_11 = 363;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_11(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13097,11 +13097,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_12 = 364;
+    private final static int mExportReduceIdx_my_uchar2_12 = 364;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_12(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13134,11 +13134,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_13 = 365;
+    private final static int mExportReduceIdx_my_uchar2_13 = 365;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_13(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13171,11 +13171,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_14 = 366;
+    private final static int mExportReduceIdx_my_uchar2_14 = 366;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_14(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13208,11 +13208,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_15 = 367;
+    private final static int mExportReduceIdx_my_uchar2_15 = 367;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uchar2_15(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13245,11 +13245,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_0 = 368;
+    private final static int mExportReduceIdx_my_uchar4_0 = 368;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_0(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13282,11 +13282,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_1 = 369;
+    private final static int mExportReduceIdx_my_uchar4_1 = 369;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_1(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13319,11 +13319,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_2 = 370;
+    private final static int mExportReduceIdx_my_uchar4_2 = 370;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13356,11 +13356,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_3 = 371;
+    private final static int mExportReduceIdx_my_uchar4_3 = 371;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_3(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13393,11 +13393,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_4 = 372;
+    private final static int mExportReduceIdx_my_uchar4_4 = 372;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13430,11 +13430,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_5 = 373;
+    private final static int mExportReduceIdx_my_uchar4_5 = 373;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_5(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13467,11 +13467,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_6 = 374;
+    private final static int mExportReduceIdx_my_uchar4_6 = 374;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_6(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13504,11 +13504,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_7 = 375;
+    private final static int mExportReduceIdx_my_uchar4_7 = 375;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_7(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13541,11 +13541,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_8 = 376;
+    private final static int mExportReduceIdx_my_uchar4_8 = 376;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_8(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13578,11 +13578,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_9 = 377;
+    private final static int mExportReduceIdx_my_uchar4_9 = 377;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_9(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13615,11 +13615,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_10 = 378;
+    private final static int mExportReduceIdx_my_uchar4_10 = 378;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_10(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13652,11 +13652,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_11 = 379;
+    private final static int mExportReduceIdx_my_uchar4_11 = 379;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_11(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13689,11 +13689,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_12 = 380;
+    private final static int mExportReduceIdx_my_uchar4_12 = 380;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_12(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13726,11 +13726,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_13 = 381;
+    private final static int mExportReduceIdx_my_uchar4_13 = 381;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_13(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13763,11 +13763,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_14 = 382;
+    private final static int mExportReduceIdx_my_uchar4_14 = 382;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_14(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13800,11 +13800,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_15 = 383;
+    private final static int mExportReduceIdx_my_uchar4_15 = 383;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uchar4_15(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -13837,11 +13837,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_0 = 384;
+    private final static int mExportReduceIdx_my_ushort_0 = 384;
     // in1 = "in"
     public result_int reduce_my_ushort_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -13870,11 +13870,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_1 = 385;
+    private final static int mExportReduceIdx_my_ushort_1 = 385;
     // in1 = "in"
     public result_int reduce_my_ushort_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -13903,11 +13903,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_2 = 386;
+    private final static int mExportReduceIdx_my_ushort_2 = 386;
     // in1 = "in"
     public result_int reduce_my_ushort_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -13936,11 +13936,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_3 = 387;
+    private final static int mExportReduceIdx_my_ushort_3 = 387;
     // in1 = "in"
     public result_int reduce_my_ushort_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -13969,11 +13969,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_4 = 388;
+    private final static int mExportReduceIdx_my_ushort_4 = 388;
     // in1 = "in"
     public result_int reduce_my_ushort_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14002,11 +14002,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_5 = 389;
+    private final static int mExportReduceIdx_my_ushort_5 = 389;
     // in1 = "in"
     public result_int reduce_my_ushort_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14035,11 +14035,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_6 = 390;
+    private final static int mExportReduceIdx_my_ushort_6 = 390;
     // in1 = "in"
     public result_int reduce_my_ushort_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14068,11 +14068,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_7 = 391;
+    private final static int mExportReduceIdx_my_ushort_7 = 391;
     // in1 = "in"
     public result_int reduce_my_ushort_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14101,11 +14101,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_8 = 392;
+    private final static int mExportReduceIdx_my_ushort_8 = 392;
     // in1 = "in"
     public result_int reduce_my_ushort_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14134,11 +14134,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_9 = 393;
+    private final static int mExportReduceIdx_my_ushort_9 = 393;
     // in1 = "in"
     public result_int reduce_my_ushort_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14167,11 +14167,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_10 = 394;
+    private final static int mExportReduceIdx_my_ushort_10 = 394;
     // in1 = "in"
     public result_int reduce_my_ushort_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14200,11 +14200,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_11 = 395;
+    private final static int mExportReduceIdx_my_ushort_11 = 395;
     // in1 = "in"
     public result_int reduce_my_ushort_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14233,11 +14233,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_12 = 396;
+    private final static int mExportReduceIdx_my_ushort_12 = 396;
     // in1 = "in"
     public result_int reduce_my_ushort_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14266,11 +14266,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_13 = 397;
+    private final static int mExportReduceIdx_my_ushort_13 = 397;
     // in1 = "in"
     public result_int reduce_my_ushort_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14299,11 +14299,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_14 = 398;
+    private final static int mExportReduceIdx_my_ushort_14 = 398;
     // in1 = "in"
     public result_int reduce_my_ushort_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14332,11 +14332,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_15 = 399;
+    private final static int mExportReduceIdx_my_ushort_15 = 399;
     // in1 = "in"
     public result_int reduce_my_ushort_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14365,11 +14365,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_0 = 400;
+    private final static int mExportReduceIdx_my_ushort2_0 = 400;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14402,11 +14402,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_1 = 401;
+    private final static int mExportReduceIdx_my_ushort2_1 = 401;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14439,11 +14439,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_2 = 402;
+    private final static int mExportReduceIdx_my_ushort2_2 = 402;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14476,11 +14476,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_3 = 403;
+    private final static int mExportReduceIdx_my_ushort2_3 = 403;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14513,11 +14513,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_4 = 404;
+    private final static int mExportReduceIdx_my_ushort2_4 = 404;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14550,11 +14550,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_5 = 405;
+    private final static int mExportReduceIdx_my_ushort2_5 = 405;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14587,11 +14587,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_6 = 406;
+    private final static int mExportReduceIdx_my_ushort2_6 = 406;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14624,11 +14624,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_7 = 407;
+    private final static int mExportReduceIdx_my_ushort2_7 = 407;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14661,11 +14661,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_8 = 408;
+    private final static int mExportReduceIdx_my_ushort2_8 = 408;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14698,11 +14698,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_9 = 409;
+    private final static int mExportReduceIdx_my_ushort2_9 = 409;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14735,11 +14735,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_10 = 410;
+    private final static int mExportReduceIdx_my_ushort2_10 = 410;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14772,11 +14772,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_11 = 411;
+    private final static int mExportReduceIdx_my_ushort2_11 = 411;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14809,11 +14809,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_12 = 412;
+    private final static int mExportReduceIdx_my_ushort2_12 = 412;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14846,11 +14846,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_13 = 413;
+    private final static int mExportReduceIdx_my_ushort2_13 = 413;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14883,11 +14883,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_14 = 414;
+    private final static int mExportReduceIdx_my_ushort2_14 = 414;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14920,11 +14920,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_15 = 415;
+    private final static int mExportReduceIdx_my_ushort2_15 = 415;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ushort2_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14957,11 +14957,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_0 = 416;
+    private final static int mExportReduceIdx_my_ushort4_0 = 416;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_0(short[] in1) {
         // Verify that "in1" is non-null.
@@ -14994,11 +14994,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_1 = 417;
+    private final static int mExportReduceIdx_my_ushort4_1 = 417;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_1(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15031,11 +15031,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_2 = 418;
+    private final static int mExportReduceIdx_my_ushort4_2 = 418;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15068,11 +15068,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_3 = 419;
+    private final static int mExportReduceIdx_my_ushort4_3 = 419;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_3(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15105,11 +15105,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_4 = 420;
+    private final static int mExportReduceIdx_my_ushort4_4 = 420;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15142,11 +15142,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_5 = 421;
+    private final static int mExportReduceIdx_my_ushort4_5 = 421;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_5(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15179,11 +15179,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_6 = 422;
+    private final static int mExportReduceIdx_my_ushort4_6 = 422;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_6(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15216,11 +15216,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_7 = 423;
+    private final static int mExportReduceIdx_my_ushort4_7 = 423;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_7(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15253,11 +15253,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_8 = 424;
+    private final static int mExportReduceIdx_my_ushort4_8 = 424;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_8(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15290,11 +15290,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_9 = 425;
+    private final static int mExportReduceIdx_my_ushort4_9 = 425;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_9(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15327,11 +15327,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_10 = 426;
+    private final static int mExportReduceIdx_my_ushort4_10 = 426;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_10(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15364,11 +15364,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_11 = 427;
+    private final static int mExportReduceIdx_my_ushort4_11 = 427;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_11(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15401,11 +15401,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_12 = 428;
+    private final static int mExportReduceIdx_my_ushort4_12 = 428;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_12(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15438,11 +15438,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_13 = 429;
+    private final static int mExportReduceIdx_my_ushort4_13 = 429;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_13(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15475,11 +15475,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_14 = 430;
+    private final static int mExportReduceIdx_my_ushort4_14 = 430;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_14(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15512,11 +15512,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_15 = 431;
+    private final static int mExportReduceIdx_my_ushort4_15 = 431;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ushort4_15(short[] in1) {
         // Verify that "in1" is non-null.
@@ -15549,11 +15549,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_0 = 432;
+    private final static int mExportReduceIdx_my_uint_0 = 432;
     // in1 = "in"
     public result_int reduce_my_uint_0(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15582,11 +15582,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_1 = 433;
+    private final static int mExportReduceIdx_my_uint_1 = 433;
     // in1 = "in"
     public result_int reduce_my_uint_1(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15615,11 +15615,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_2 = 434;
+    private final static int mExportReduceIdx_my_uint_2 = 434;
     // in1 = "in"
     public result_int reduce_my_uint_2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15648,11 +15648,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_3 = 435;
+    private final static int mExportReduceIdx_my_uint_3 = 435;
     // in1 = "in"
     public result_int reduce_my_uint_3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15681,11 +15681,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_4 = 436;
+    private final static int mExportReduceIdx_my_uint_4 = 436;
     // in1 = "in"
     public result_int reduce_my_uint_4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15714,11 +15714,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_5 = 437;
+    private final static int mExportReduceIdx_my_uint_5 = 437;
     // in1 = "in"
     public result_int reduce_my_uint_5(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15747,11 +15747,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_6 = 438;
+    private final static int mExportReduceIdx_my_uint_6 = 438;
     // in1 = "in"
     public result_int reduce_my_uint_6(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15780,11 +15780,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_7 = 439;
+    private final static int mExportReduceIdx_my_uint_7 = 439;
     // in1 = "in"
     public result_int reduce_my_uint_7(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15813,11 +15813,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_8 = 440;
+    private final static int mExportReduceIdx_my_uint_8 = 440;
     // in1 = "in"
     public result_int reduce_my_uint_8(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15846,11 +15846,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_9 = 441;
+    private final static int mExportReduceIdx_my_uint_9 = 441;
     // in1 = "in"
     public result_int reduce_my_uint_9(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15879,11 +15879,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_10 = 442;
+    private final static int mExportReduceIdx_my_uint_10 = 442;
     // in1 = "in"
     public result_int reduce_my_uint_10(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15912,11 +15912,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_11 = 443;
+    private final static int mExportReduceIdx_my_uint_11 = 443;
     // in1 = "in"
     public result_int reduce_my_uint_11(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15945,11 +15945,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_12 = 444;
+    private final static int mExportReduceIdx_my_uint_12 = 444;
     // in1 = "in"
     public result_int reduce_my_uint_12(int[] in1) {
         // Verify that "in1" is non-null.
@@ -15978,11 +15978,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_13 = 445;
+    private final static int mExportReduceIdx_my_uint_13 = 445;
     // in1 = "in"
     public result_int reduce_my_uint_13(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16011,11 +16011,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_14 = 446;
+    private final static int mExportReduceIdx_my_uint_14 = 446;
     // in1 = "in"
     public result_int reduce_my_uint_14(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16044,11 +16044,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint_15 = 447;
+    private final static int mExportReduceIdx_my_uint_15 = 447;
     // in1 = "in"
     public result_int reduce_my_uint_15(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16077,11 +16077,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_0 = 448;
+    private final static int mExportReduceIdx_my_uint2_0 = 448;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_0(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16114,11 +16114,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_1 = 449;
+    private final static int mExportReduceIdx_my_uint2_1 = 449;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_1(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16151,11 +16151,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_2 = 450;
+    private final static int mExportReduceIdx_my_uint2_2 = 450;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16188,11 +16188,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_3 = 451;
+    private final static int mExportReduceIdx_my_uint2_3 = 451;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16225,11 +16225,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_4 = 452;
+    private final static int mExportReduceIdx_my_uint2_4 = 452;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16262,11 +16262,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_5 = 453;
+    private final static int mExportReduceIdx_my_uint2_5 = 453;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_5(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16299,11 +16299,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_6 = 454;
+    private final static int mExportReduceIdx_my_uint2_6 = 454;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_6(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16336,11 +16336,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_7 = 455;
+    private final static int mExportReduceIdx_my_uint2_7 = 455;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_7(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16373,11 +16373,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_8 = 456;
+    private final static int mExportReduceIdx_my_uint2_8 = 456;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_8(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16410,11 +16410,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_9 = 457;
+    private final static int mExportReduceIdx_my_uint2_9 = 457;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_9(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16447,11 +16447,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_10 = 458;
+    private final static int mExportReduceIdx_my_uint2_10 = 458;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_10(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16484,11 +16484,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_11 = 459;
+    private final static int mExportReduceIdx_my_uint2_11 = 459;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_11(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16521,11 +16521,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_12 = 460;
+    private final static int mExportReduceIdx_my_uint2_12 = 460;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_12(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16558,11 +16558,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_13 = 461;
+    private final static int mExportReduceIdx_my_uint2_13 = 461;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_13(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16595,11 +16595,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_14 = 462;
+    private final static int mExportReduceIdx_my_uint2_14 = 462;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_14(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16632,11 +16632,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2_15 = 463;
+    private final static int mExportReduceIdx_my_uint2_15 = 463;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_uint2_15(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16669,11 +16669,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_0 = 464;
+    private final static int mExportReduceIdx_my_uint4_0 = 464;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_0(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16706,11 +16706,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_1 = 465;
+    private final static int mExportReduceIdx_my_uint4_1 = 465;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_1(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16743,11 +16743,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_2 = 466;
+    private final static int mExportReduceIdx_my_uint4_2 = 466;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16780,11 +16780,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_3 = 467;
+    private final static int mExportReduceIdx_my_uint4_3 = 467;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_3(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16817,11 +16817,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_4 = 468;
+    private final static int mExportReduceIdx_my_uint4_4 = 468;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16854,11 +16854,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_5 = 469;
+    private final static int mExportReduceIdx_my_uint4_5 = 469;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_5(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16891,11 +16891,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_6 = 470;
+    private final static int mExportReduceIdx_my_uint4_6 = 470;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_6(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16928,11 +16928,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_7 = 471;
+    private final static int mExportReduceIdx_my_uint4_7 = 471;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_7(int[] in1) {
         // Verify that "in1" is non-null.
@@ -16965,11 +16965,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_8 = 472;
+    private final static int mExportReduceIdx_my_uint4_8 = 472;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_8(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17002,11 +17002,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_9 = 473;
+    private final static int mExportReduceIdx_my_uint4_9 = 473;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_9(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17039,11 +17039,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_10 = 474;
+    private final static int mExportReduceIdx_my_uint4_10 = 474;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_10(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17076,11 +17076,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_11 = 475;
+    private final static int mExportReduceIdx_my_uint4_11 = 475;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_11(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17113,11 +17113,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_12 = 476;
+    private final static int mExportReduceIdx_my_uint4_12 = 476;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_12(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17150,11 +17150,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_13 = 477;
+    private final static int mExportReduceIdx_my_uint4_13 = 477;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_13(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17187,11 +17187,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_14 = 478;
+    private final static int mExportReduceIdx_my_uint4_14 = 478;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_14(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17224,11 +17224,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4_15 = 479;
+    private final static int mExportReduceIdx_my_uint4_15 = 479;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_uint4_15(int[] in1) {
         // Verify that "in1" is non-null.
@@ -17261,11 +17261,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_0 = 480;
+    private final static int mExportReduceIdx_my_ulong_0 = 480;
     // in1 = "in"
     public result_int reduce_my_ulong_0(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17294,11 +17294,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_1 = 481;
+    private final static int mExportReduceIdx_my_ulong_1 = 481;
     // in1 = "in"
     public result_int reduce_my_ulong_1(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17327,11 +17327,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_2 = 482;
+    private final static int mExportReduceIdx_my_ulong_2 = 482;
     // in1 = "in"
     public result_int reduce_my_ulong_2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17360,11 +17360,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_3 = 483;
+    private final static int mExportReduceIdx_my_ulong_3 = 483;
     // in1 = "in"
     public result_int reduce_my_ulong_3(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17393,11 +17393,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_4 = 484;
+    private final static int mExportReduceIdx_my_ulong_4 = 484;
     // in1 = "in"
     public result_int reduce_my_ulong_4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17426,11 +17426,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_5 = 485;
+    private final static int mExportReduceIdx_my_ulong_5 = 485;
     // in1 = "in"
     public result_int reduce_my_ulong_5(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17459,11 +17459,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_6 = 486;
+    private final static int mExportReduceIdx_my_ulong_6 = 486;
     // in1 = "in"
     public result_int reduce_my_ulong_6(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17492,11 +17492,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_7 = 487;
+    private final static int mExportReduceIdx_my_ulong_7 = 487;
     // in1 = "in"
     public result_int reduce_my_ulong_7(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17525,11 +17525,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_8 = 488;
+    private final static int mExportReduceIdx_my_ulong_8 = 488;
     // in1 = "in"
     public result_int reduce_my_ulong_8(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17558,11 +17558,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_9 = 489;
+    private final static int mExportReduceIdx_my_ulong_9 = 489;
     // in1 = "in"
     public result_int reduce_my_ulong_9(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17591,11 +17591,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_10 = 490;
+    private final static int mExportReduceIdx_my_ulong_10 = 490;
     // in1 = "in"
     public result_int reduce_my_ulong_10(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17624,11 +17624,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_11 = 491;
+    private final static int mExportReduceIdx_my_ulong_11 = 491;
     // in1 = "in"
     public result_int reduce_my_ulong_11(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17657,11 +17657,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_12 = 492;
+    private final static int mExportReduceIdx_my_ulong_12 = 492;
     // in1 = "in"
     public result_int reduce_my_ulong_12(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17690,11 +17690,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_13 = 493;
+    private final static int mExportReduceIdx_my_ulong_13 = 493;
     // in1 = "in"
     public result_int reduce_my_ulong_13(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17723,11 +17723,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_14 = 494;
+    private final static int mExportReduceIdx_my_ulong_14 = 494;
     // in1 = "in"
     public result_int reduce_my_ulong_14(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17756,11 +17756,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong_15 = 495;
+    private final static int mExportReduceIdx_my_ulong_15 = 495;
     // in1 = "in"
     public result_int reduce_my_ulong_15(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17789,11 +17789,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_0 = 496;
+    private final static int mExportReduceIdx_my_ulong2_0 = 496;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_0(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17826,11 +17826,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_1 = 497;
+    private final static int mExportReduceIdx_my_ulong2_1 = 497;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_1(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17863,11 +17863,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_2 = 498;
+    private final static int mExportReduceIdx_my_ulong2_2 = 498;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17900,11 +17900,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_3 = 499;
+    private final static int mExportReduceIdx_my_ulong2_3 = 499;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_3(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17937,11 +17937,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_4 = 500;
+    private final static int mExportReduceIdx_my_ulong2_4 = 500;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -17974,11 +17974,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_5 = 501;
+    private final static int mExportReduceIdx_my_ulong2_5 = 501;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_5(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18011,11 +18011,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_6 = 502;
+    private final static int mExportReduceIdx_my_ulong2_6 = 502;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_6(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18048,11 +18048,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_7 = 503;
+    private final static int mExportReduceIdx_my_ulong2_7 = 503;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_7(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18085,11 +18085,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_8 = 504;
+    private final static int mExportReduceIdx_my_ulong2_8 = 504;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_8(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18122,11 +18122,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_9 = 505;
+    private final static int mExportReduceIdx_my_ulong2_9 = 505;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_9(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18159,11 +18159,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_10 = 506;
+    private final static int mExportReduceIdx_my_ulong2_10 = 506;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_10(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18196,11 +18196,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_11 = 507;
+    private final static int mExportReduceIdx_my_ulong2_11 = 507;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_11(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18233,11 +18233,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_12 = 508;
+    private final static int mExportReduceIdx_my_ulong2_12 = 508;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_12(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18270,11 +18270,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_13 = 509;
+    private final static int mExportReduceIdx_my_ulong2_13 = 509;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_13(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18307,11 +18307,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_14 = 510;
+    private final static int mExportReduceIdx_my_ulong2_14 = 510;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_14(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18344,11 +18344,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2_15 = 511;
+    private final static int mExportReduceIdx_my_ulong2_15 = 511;
     // in1 = "in", flattened 2-vectors
     public result_int reduce_my_ulong2_15(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18381,11 +18381,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_0 = 512;
+    private final static int mExportReduceIdx_my_ulong4_0 = 512;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_0(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18418,11 +18418,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_1 = 513;
+    private final static int mExportReduceIdx_my_ulong4_1 = 513;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_1(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18455,11 +18455,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_2 = 514;
+    private final static int mExportReduceIdx_my_ulong4_2 = 514;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18492,11 +18492,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_3 = 515;
+    private final static int mExportReduceIdx_my_ulong4_3 = 515;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_3(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18529,11 +18529,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_4 = 516;
+    private final static int mExportReduceIdx_my_ulong4_4 = 516;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18566,11 +18566,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_5 = 517;
+    private final static int mExportReduceIdx_my_ulong4_5 = 517;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_5(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18603,11 +18603,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_6 = 518;
+    private final static int mExportReduceIdx_my_ulong4_6 = 518;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_6(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18640,11 +18640,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_7 = 519;
+    private final static int mExportReduceIdx_my_ulong4_7 = 519;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_7(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18677,11 +18677,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_8 = 520;
+    private final static int mExportReduceIdx_my_ulong4_8 = 520;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_8(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18714,11 +18714,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_9 = 521;
+    private final static int mExportReduceIdx_my_ulong4_9 = 521;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_9(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18751,11 +18751,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_10 = 522;
+    private final static int mExportReduceIdx_my_ulong4_10 = 522;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_10(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18788,11 +18788,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_11 = 523;
+    private final static int mExportReduceIdx_my_ulong4_11 = 523;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_11(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18825,11 +18825,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_12 = 524;
+    private final static int mExportReduceIdx_my_ulong4_12 = 524;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_12(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18862,11 +18862,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_13 = 525;
+    private final static int mExportReduceIdx_my_ulong4_13 = 525;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_13(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18899,11 +18899,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_14 = 526;
+    private final static int mExportReduceIdx_my_ulong4_14 = 526;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_14(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18936,11 +18936,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4_15 = 527;
+    private final static int mExportReduceIdx_my_ulong4_15 = 527;
     // in1 = "in", flattened 4-vectors
     public result_int reduce_my_ulong4_15(long[] in1) {
         // Verify that "in1" is non-null.
@@ -18973,11 +18973,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_0 = 528;
+    private final static int mExportReduceIdx_my_bool_0 = 528;
     // in1 = "in"
     public result_int reduce_my_bool_0(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19006,11 +19006,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_1 = 529;
+    private final static int mExportReduceIdx_my_bool_1 = 529;
     // in1 = "in"
     public result_int reduce_my_bool_1(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19039,11 +19039,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_2 = 530;
+    private final static int mExportReduceIdx_my_bool_2 = 530;
     // in1 = "in"
     public result_int reduce_my_bool_2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19072,11 +19072,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_3 = 531;
+    private final static int mExportReduceIdx_my_bool_3 = 531;
     // in1 = "in"
     public result_int reduce_my_bool_3(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19105,11 +19105,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_4 = 532;
+    private final static int mExportReduceIdx_my_bool_4 = 532;
     // in1 = "in"
     public result_int reduce_my_bool_4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19138,11 +19138,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_5 = 533;
+    private final static int mExportReduceIdx_my_bool_5 = 533;
     // in1 = "in"
     public result_int reduce_my_bool_5(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19171,11 +19171,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_6 = 534;
+    private final static int mExportReduceIdx_my_bool_6 = 534;
     // in1 = "in"
     public result_int reduce_my_bool_6(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19204,11 +19204,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_7 = 535;
+    private final static int mExportReduceIdx_my_bool_7 = 535;
     // in1 = "in"
     public result_int reduce_my_bool_7(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19237,11 +19237,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_8 = 536;
+    private final static int mExportReduceIdx_my_bool_8 = 536;
     // in1 = "in"
     public result_int reduce_my_bool_8(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19270,11 +19270,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_9 = 537;
+    private final static int mExportReduceIdx_my_bool_9 = 537;
     // in1 = "in"
     public result_int reduce_my_bool_9(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19303,11 +19303,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_10 = 538;
+    private final static int mExportReduceIdx_my_bool_10 = 538;
     // in1 = "in"
     public result_int reduce_my_bool_10(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19336,11 +19336,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_11 = 539;
+    private final static int mExportReduceIdx_my_bool_11 = 539;
     // in1 = "in"
     public result_int reduce_my_bool_11(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19369,11 +19369,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_12 = 540;
+    private final static int mExportReduceIdx_my_bool_12 = 540;
     // in1 = "in"
     public result_int reduce_my_bool_12(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19402,11 +19402,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_13 = 541;
+    private final static int mExportReduceIdx_my_bool_13 = 541;
     // in1 = "in"
     public result_int reduce_my_bool_13(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19435,11 +19435,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_14 = 542;
+    private final static int mExportReduceIdx_my_bool_14 = 542;
     // in1 = "in"
     public result_int reduce_my_bool_14(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19468,11 +19468,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_15 = 543;
+    private final static int mExportReduceIdx_my_bool_15 = 543;
     // in1 = "in"
     public result_int reduce_my_bool_15(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -19501,11 +19501,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_0 = 544;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_0 = 544;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_0(Allocation ain1) {
         return reduce_my_rs_matrix2x2_0(ain1, null);
@@ -19516,11 +19516,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_1 = 545;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_1 = 545;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_1(Allocation ain1) {
         return reduce_my_rs_matrix2x2_1(ain1, null);
@@ -19531,11 +19531,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_2 = 546;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_2 = 546;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_2(Allocation ain1) {
         return reduce_my_rs_matrix2x2_2(ain1, null);
@@ -19546,11 +19546,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_3 = 547;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_3 = 547;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_3(Allocation ain1) {
         return reduce_my_rs_matrix2x2_3(ain1, null);
@@ -19561,11 +19561,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_4 = 548;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_4 = 548;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_4(Allocation ain1) {
         return reduce_my_rs_matrix2x2_4(ain1, null);
@@ -19576,11 +19576,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_5 = 549;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_5 = 549;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_5(Allocation ain1) {
         return reduce_my_rs_matrix2x2_5(ain1, null);
@@ -19591,11 +19591,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_6 = 550;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_6 = 550;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_6(Allocation ain1) {
         return reduce_my_rs_matrix2x2_6(ain1, null);
@@ -19606,11 +19606,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_7 = 551;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_7 = 551;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_7(Allocation ain1) {
         return reduce_my_rs_matrix2x2_7(ain1, null);
@@ -19621,11 +19621,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_8 = 552;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_8 = 552;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_8(Allocation ain1) {
         return reduce_my_rs_matrix2x2_8(ain1, null);
@@ -19636,11 +19636,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_9 = 553;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_9 = 553;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_9(Allocation ain1) {
         return reduce_my_rs_matrix2x2_9(ain1, null);
@@ -19651,11 +19651,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_10 = 554;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_10 = 554;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_10(Allocation ain1) {
         return reduce_my_rs_matrix2x2_10(ain1, null);
@@ -19666,11 +19666,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_11 = 555;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_11 = 555;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_11(Allocation ain1) {
         return reduce_my_rs_matrix2x2_11(ain1, null);
@@ -19681,11 +19681,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_12 = 556;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_12 = 556;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_12(Allocation ain1) {
         return reduce_my_rs_matrix2x2_12(ain1, null);
@@ -19696,11 +19696,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_13 = 557;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_13 = 557;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_13(Allocation ain1) {
         return reduce_my_rs_matrix2x2_13(ain1, null);
@@ -19711,11 +19711,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_14 = 558;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_14 = 558;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_14(Allocation ain1) {
         return reduce_my_rs_matrix2x2_14(ain1, null);
@@ -19726,11 +19726,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_15 = 559;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_15 = 559;
     // ain1 = "rs_matrix2x2 in"
     public result_int reduce_my_rs_matrix2x2_15(Allocation ain1) {
         return reduce_my_rs_matrix2x2_15(ain1, null);
@@ -19741,11 +19741,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_0 = 560;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_0 = 560;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_0(Allocation ain1) {
         return reduce_my_rs_matrix3x3_0(ain1, null);
@@ -19756,11 +19756,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_1 = 561;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_1 = 561;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_1(Allocation ain1) {
         return reduce_my_rs_matrix3x3_1(ain1, null);
@@ -19771,11 +19771,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_2 = 562;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_2 = 562;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_2(Allocation ain1) {
         return reduce_my_rs_matrix3x3_2(ain1, null);
@@ -19786,11 +19786,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_3 = 563;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_3 = 563;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_3(Allocation ain1) {
         return reduce_my_rs_matrix3x3_3(ain1, null);
@@ -19801,11 +19801,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_4 = 564;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_4 = 564;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_4(Allocation ain1) {
         return reduce_my_rs_matrix3x3_4(ain1, null);
@@ -19816,11 +19816,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_5 = 565;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_5 = 565;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_5(Allocation ain1) {
         return reduce_my_rs_matrix3x3_5(ain1, null);
@@ -19831,11 +19831,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_6 = 566;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_6 = 566;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_6(Allocation ain1) {
         return reduce_my_rs_matrix3x3_6(ain1, null);
@@ -19846,11 +19846,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_7 = 567;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_7 = 567;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_7(Allocation ain1) {
         return reduce_my_rs_matrix3x3_7(ain1, null);
@@ -19861,11 +19861,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_8 = 568;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_8 = 568;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_8(Allocation ain1) {
         return reduce_my_rs_matrix3x3_8(ain1, null);
@@ -19876,11 +19876,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_9 = 569;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_9 = 569;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_9(Allocation ain1) {
         return reduce_my_rs_matrix3x3_9(ain1, null);
@@ -19891,11 +19891,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_10 = 570;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_10 = 570;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_10(Allocation ain1) {
         return reduce_my_rs_matrix3x3_10(ain1, null);
@@ -19906,11 +19906,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_11 = 571;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_11 = 571;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_11(Allocation ain1) {
         return reduce_my_rs_matrix3x3_11(ain1, null);
@@ -19921,11 +19921,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_12 = 572;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_12 = 572;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_12(Allocation ain1) {
         return reduce_my_rs_matrix3x3_12(ain1, null);
@@ -19936,11 +19936,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_13 = 573;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_13 = 573;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_13(Allocation ain1) {
         return reduce_my_rs_matrix3x3_13(ain1, null);
@@ -19951,11 +19951,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_14 = 574;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_14 = 574;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_14(Allocation ain1) {
         return reduce_my_rs_matrix3x3_14(ain1, null);
@@ -19966,11 +19966,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix3x3_15 = 575;
+    private final static int mExportReduceIdx_my_rs_matrix3x3_15 = 575;
     // ain1 = "rs_matrix3x3 in"
     public result_int reduce_my_rs_matrix3x3_15(Allocation ain1) {
         return reduce_my_rs_matrix3x3_15(ain1, null);
@@ -19981,11 +19981,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix3x3_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix3x3_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_0 = 576;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_0 = 576;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_0(Allocation ain1) {
         return reduce_my_rs_matrix4x4_0(ain1, null);
@@ -19996,11 +19996,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_1 = 577;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_1 = 577;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_1(Allocation ain1) {
         return reduce_my_rs_matrix4x4_1(ain1, null);
@@ -20011,11 +20011,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_2 = 578;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_2 = 578;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_2(Allocation ain1) {
         return reduce_my_rs_matrix4x4_2(ain1, null);
@@ -20026,11 +20026,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_3 = 579;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_3 = 579;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_3(Allocation ain1) {
         return reduce_my_rs_matrix4x4_3(ain1, null);
@@ -20041,11 +20041,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_4 = 580;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_4 = 580;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_4(Allocation ain1) {
         return reduce_my_rs_matrix4x4_4(ain1, null);
@@ -20056,11 +20056,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_5 = 581;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_5 = 581;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_5(Allocation ain1) {
         return reduce_my_rs_matrix4x4_5(ain1, null);
@@ -20071,11 +20071,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_6 = 582;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_6 = 582;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_6(Allocation ain1) {
         return reduce_my_rs_matrix4x4_6(ain1, null);
@@ -20086,11 +20086,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_7 = 583;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_7 = 583;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_7(Allocation ain1) {
         return reduce_my_rs_matrix4x4_7(ain1, null);
@@ -20101,11 +20101,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_8 = 584;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_8 = 584;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_8(Allocation ain1) {
         return reduce_my_rs_matrix4x4_8(ain1, null);
@@ -20116,11 +20116,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_9 = 585;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_9 = 585;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_9(Allocation ain1) {
         return reduce_my_rs_matrix4x4_9(ain1, null);
@@ -20131,11 +20131,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_10 = 586;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_10 = 586;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_10(Allocation ain1) {
         return reduce_my_rs_matrix4x4_10(ain1, null);
@@ -20146,11 +20146,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_11 = 587;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_11 = 587;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_11(Allocation ain1) {
         return reduce_my_rs_matrix4x4_11(ain1, null);
@@ -20161,11 +20161,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_12 = 588;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_12 = 588;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_12(Allocation ain1) {
         return reduce_my_rs_matrix4x4_12(ain1, null);
@@ -20176,11 +20176,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_13 = 589;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_13 = 589;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_13(Allocation ain1) {
         return reduce_my_rs_matrix4x4_13(ain1, null);
@@ -20191,11 +20191,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_14 = 590;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_14 = 590;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_14(Allocation ain1) {
         return reduce_my_rs_matrix4x4_14(ain1, null);
@@ -20206,11 +20206,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix4x4_15 = 591;
+    private final static int mExportReduceIdx_my_rs_matrix4x4_15 = 591;
     // ain1 = "rs_matrix4x4 in"
     public result_int reduce_my_rs_matrix4x4_15(Allocation ain1) {
         return reduce_my_rs_matrix4x4_15(ain1, null);
@@ -20221,11 +20221,11 @@
         // check ain1
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix4x4_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix4x4_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_0 = 592;
+    private final static int mExportReduceIdx_my_MyStruct_0 = 592;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_0(Allocation ain1) {
         return reduce_my_MyStruct_0(ain1, null);
@@ -20239,11 +20239,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_0, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_0, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_1 = 593;
+    private final static int mExportReduceIdx_my_MyStruct_1 = 593;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_1(Allocation ain1) {
         return reduce_my_MyStruct_1(ain1, null);
@@ -20257,11 +20257,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_1, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_1, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_2 = 594;
+    private final static int mExportReduceIdx_my_MyStruct_2 = 594;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_2(Allocation ain1) {
         return reduce_my_MyStruct_2(ain1, null);
@@ -20275,11 +20275,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_2, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_3 = 595;
+    private final static int mExportReduceIdx_my_MyStruct_3 = 595;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_3(Allocation ain1) {
         return reduce_my_MyStruct_3(ain1, null);
@@ -20293,11 +20293,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_3, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_3, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_4 = 596;
+    private final static int mExportReduceIdx_my_MyStruct_4 = 596;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_4(Allocation ain1) {
         return reduce_my_MyStruct_4(ain1, null);
@@ -20311,11 +20311,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_4, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_5 = 597;
+    private final static int mExportReduceIdx_my_MyStruct_5 = 597;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_5(Allocation ain1) {
         return reduce_my_MyStruct_5(ain1, null);
@@ -20329,11 +20329,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_5, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_5, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_6 = 598;
+    private final static int mExportReduceIdx_my_MyStruct_6 = 598;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_6(Allocation ain1) {
         return reduce_my_MyStruct_6(ain1, null);
@@ -20347,11 +20347,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_6, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_6, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_7 = 599;
+    private final static int mExportReduceIdx_my_MyStruct_7 = 599;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_7(Allocation ain1) {
         return reduce_my_MyStruct_7(ain1, null);
@@ -20365,11 +20365,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_7, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_7, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_8 = 600;
+    private final static int mExportReduceIdx_my_MyStruct_8 = 600;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_8(Allocation ain1) {
         return reduce_my_MyStruct_8(ain1, null);
@@ -20383,11 +20383,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_8, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_8, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_9 = 601;
+    private final static int mExportReduceIdx_my_MyStruct_9 = 601;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_9(Allocation ain1) {
         return reduce_my_MyStruct_9(ain1, null);
@@ -20401,11 +20401,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_9, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_9, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_10 = 602;
+    private final static int mExportReduceIdx_my_MyStruct_10 = 602;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_10(Allocation ain1) {
         return reduce_my_MyStruct_10(ain1, null);
@@ -20419,11 +20419,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_10, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_10, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_11 = 603;
+    private final static int mExportReduceIdx_my_MyStruct_11 = 603;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_11(Allocation ain1) {
         return reduce_my_MyStruct_11(ain1, null);
@@ -20437,11 +20437,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_11, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_11, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_12 = 604;
+    private final static int mExportReduceIdx_my_MyStruct_12 = 604;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_12(Allocation ain1) {
         return reduce_my_MyStruct_12(ain1, null);
@@ -20455,11 +20455,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_12, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_12, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_13 = 605;
+    private final static int mExportReduceIdx_my_MyStruct_13 = 605;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_13(Allocation ain1) {
         return reduce_my_MyStruct_13(ain1, null);
@@ -20473,11 +20473,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_13, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_13, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_14 = 606;
+    private final static int mExportReduceIdx_my_MyStruct_14 = 606;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_14(Allocation ain1) {
         return reduce_my_MyStruct_14(ain1, null);
@@ -20491,11 +20491,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_14, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_14, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_15 = 607;
+    private final static int mExportReduceIdx_my_MyStruct_15 = 607;
     // ain1 = "/* struct <> */ in"
     public result_int reduce_my_MyStruct_15(Allocation ain1) {
         return reduce_my_MyStruct_15(ain1, null);
@@ -20509,7 +20509,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_15, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_15, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
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 fd98a92..05b80ad 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
@@ -117,7 +117,7 @@
         private int mResult;
     }
 
-    private final static int mExportReduceNewIdx_my_half_half_0 = 0;
+    private final static int mExportReduceIdx_my_half_half_0 = 0;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_half_0(short[] in1, short[] in2) {
@@ -177,11 +177,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_half_1 = 1;
+    private final static int mExportReduceIdx_my_half_half_1 = 1;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_half_1(short[] in1, short[] in2) {
@@ -241,11 +241,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_half2_0 = 2;
+    private final static int mExportReduceIdx_my_half_half2_0 = 2;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_half2_0(short[] in1, short[] in2) {
@@ -309,11 +309,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_half2_1 = 3;
+    private final static int mExportReduceIdx_my_half_half2_1 = 3;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_half2_1(short[] in1, short[] in2) {
@@ -377,11 +377,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_half4_0 = 4;
+    private final static int mExportReduceIdx_my_half_half4_0 = 4;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_half4_0(short[] in1, short[] in2) {
@@ -445,11 +445,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_half4_1 = 5;
+    private final static int mExportReduceIdx_my_half_half4_1 = 5;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_half4_1(short[] in1, short[] in2) {
@@ -513,11 +513,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_float_0 = 6;
+    private final static int mExportReduceIdx_my_half_float_0 = 6;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_float_0(short[] in1, float[] in2) {
@@ -577,11 +577,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_float_1 = 7;
+    private final static int mExportReduceIdx_my_half_float_1 = 7;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_float_1(short[] in1, float[] in2) {
@@ -641,11 +641,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_float2_0 = 8;
+    private final static int mExportReduceIdx_my_half_float2_0 = 8;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_float2_0(short[] in1, float[] in2) {
@@ -709,11 +709,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_float2_1 = 9;
+    private final static int mExportReduceIdx_my_half_float2_1 = 9;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_float2_1(short[] in1, float[] in2) {
@@ -777,11 +777,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_float4_0 = 10;
+    private final static int mExportReduceIdx_my_half_float4_0 = 10;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_float4_0(short[] in1, float[] in2) {
@@ -845,11 +845,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_float4_1 = 11;
+    private final static int mExportReduceIdx_my_half_float4_1 = 11;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_float4_1(short[] in1, float[] in2) {
@@ -913,11 +913,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_char_0 = 12;
+    private final static int mExportReduceIdx_my_half_char_0 = 12;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_char_0(short[] in1, byte[] in2) {
@@ -977,11 +977,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_char_1 = 13;
+    private final static int mExportReduceIdx_my_half_char_1 = 13;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_char_1(short[] in1, byte[] in2) {
@@ -1041,11 +1041,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_char2_0 = 14;
+    private final static int mExportReduceIdx_my_half_char2_0 = 14;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_char2_0(short[] in1, byte[] in2) {
@@ -1109,11 +1109,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_char2_1 = 15;
+    private final static int mExportReduceIdx_my_half_char2_1 = 15;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_char2_1(short[] in1, byte[] in2) {
@@ -1177,11 +1177,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_char4_0 = 16;
+    private final static int mExportReduceIdx_my_half_char4_0 = 16;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_char4_0(short[] in1, byte[] in2) {
@@ -1245,11 +1245,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_char4_1 = 17;
+    private final static int mExportReduceIdx_my_half_char4_1 = 17;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_char4_1(short[] in1, byte[] in2) {
@@ -1313,11 +1313,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_short_0 = 18;
+    private final static int mExportReduceIdx_my_half_short_0 = 18;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_short_0(short[] in1, short[] in2) {
@@ -1377,11 +1377,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_short_1 = 19;
+    private final static int mExportReduceIdx_my_half_short_1 = 19;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_short_1(short[] in1, short[] in2) {
@@ -1441,11 +1441,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_short2_0 = 20;
+    private final static int mExportReduceIdx_my_half_short2_0 = 20;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_short2_0(short[] in1, short[] in2) {
@@ -1509,11 +1509,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_short2_1 = 21;
+    private final static int mExportReduceIdx_my_half_short2_1 = 21;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_short2_1(short[] in1, short[] in2) {
@@ -1577,11 +1577,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_short4_0 = 22;
+    private final static int mExportReduceIdx_my_half_short4_0 = 22;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_short4_0(short[] in1, short[] in2) {
@@ -1645,11 +1645,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_short4_1 = 23;
+    private final static int mExportReduceIdx_my_half_short4_1 = 23;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_short4_1(short[] in1, short[] in2) {
@@ -1713,11 +1713,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_uchar_0 = 24;
+    private final static int mExportReduceIdx_my_half_uchar_0 = 24;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_uchar_0(short[] in1, byte[] in2) {
@@ -1777,11 +1777,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_uchar_1 = 25;
+    private final static int mExportReduceIdx_my_half_uchar_1 = 25;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_uchar_1(short[] in1, byte[] in2) {
@@ -1841,11 +1841,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_uchar2_0 = 26;
+    private final static int mExportReduceIdx_my_half_uchar2_0 = 26;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_uchar2_0(short[] in1, byte[] in2) {
@@ -1909,11 +1909,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_uchar2_1 = 27;
+    private final static int mExportReduceIdx_my_half_uchar2_1 = 27;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_uchar2_1(short[] in1, byte[] in2) {
@@ -1977,11 +1977,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_uchar4_0 = 28;
+    private final static int mExportReduceIdx_my_half_uchar4_0 = 28;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_uchar4_0(short[] in1, byte[] in2) {
@@ -2045,11 +2045,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_uchar4_1 = 29;
+    private final static int mExportReduceIdx_my_half_uchar4_1 = 29;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_uchar4_1(short[] in1, byte[] in2) {
@@ -2113,11 +2113,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_ushort_0 = 30;
+    private final static int mExportReduceIdx_my_half_ushort_0 = 30;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_ushort_0(short[] in1, short[] in2) {
@@ -2177,11 +2177,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_ushort_1 = 31;
+    private final static int mExportReduceIdx_my_half_ushort_1 = 31;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_ushort_1(short[] in1, short[] in2) {
@@ -2241,11 +2241,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_ushort2_0 = 32;
+    private final static int mExportReduceIdx_my_half_ushort2_0 = 32;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_ushort2_0(short[] in1, short[] in2) {
@@ -2309,11 +2309,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_ushort2_1 = 33;
+    private final static int mExportReduceIdx_my_half_ushort2_1 = 33;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_half_ushort2_1(short[] in1, short[] in2) {
@@ -2377,11 +2377,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_ushort4_0 = 34;
+    private final static int mExportReduceIdx_my_half_ushort4_0 = 34;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_ushort4_0(short[] in1, short[] in2) {
@@ -2445,11 +2445,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_ushort4_1 = 35;
+    private final static int mExportReduceIdx_my_half_ushort4_1 = 35;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_half_ushort4_1(short[] in1, short[] in2) {
@@ -2513,11 +2513,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_bool_0 = 36;
+    private final static int mExportReduceIdx_my_half_bool_0 = 36;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_bool_0(short[] in1, byte[] in2) {
@@ -2577,11 +2577,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_bool_1 = 37;
+    private final static int mExportReduceIdx_my_half_bool_1 = 37;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_half_bool_1(short[] in1, byte[] in2) {
@@ -2641,11 +2641,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_rs_matrix2x2_0 = 38;
+    private final static int mExportReduceIdx_my_half_rs_matrix2x2_0 = 38;
     // ain1 = "half a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_half_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -2675,11 +2675,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_rs_matrix2x2_1 = 39;
+    private final static int mExportReduceIdx_my_half_rs_matrix2x2_1 = 39;
     // ain1 = "half a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_half_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -2709,11 +2709,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_MyStruct_0 = 40;
+    private final static int mExportReduceIdx_my_half_MyStruct_0 = 40;
     // ain1 = "half a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_half_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -2746,11 +2746,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half_MyStruct_1 = 41;
+    private final static int mExportReduceIdx_my_half_MyStruct_1 = 41;
     // ain1 = "half a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_half_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -2783,11 +2783,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_half_0 = 42;
+    private final static int mExportReduceIdx_my_half2_half_0 = 42;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_half_0(short[] in1, short[] in2) {
@@ -2851,11 +2851,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_half_1 = 43;
+    private final static int mExportReduceIdx_my_half2_half_1 = 43;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_half_1(short[] in1, short[] in2) {
@@ -2919,11 +2919,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_half2_0 = 44;
+    private final static int mExportReduceIdx_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) {
@@ -2991,11 +2991,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_half2_1 = 45;
+    private final static int mExportReduceIdx_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) {
@@ -3063,11 +3063,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_half4_0 = 46;
+    private final static int mExportReduceIdx_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) {
@@ -3135,11 +3135,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_half4_1 = 47;
+    private final static int mExportReduceIdx_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) {
@@ -3207,11 +3207,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_float_0 = 48;
+    private final static int mExportReduceIdx_my_half2_float_0 = 48;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_float_0(short[] in1, float[] in2) {
@@ -3275,11 +3275,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_float_1 = 49;
+    private final static int mExportReduceIdx_my_half2_float_1 = 49;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_float_1(short[] in1, float[] in2) {
@@ -3343,11 +3343,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_float2_0 = 50;
+    private final static int mExportReduceIdx_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) {
@@ -3415,11 +3415,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_float2_1 = 51;
+    private final static int mExportReduceIdx_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) {
@@ -3487,11 +3487,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_float4_0 = 52;
+    private final static int mExportReduceIdx_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) {
@@ -3559,11 +3559,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_float4_1 = 53;
+    private final static int mExportReduceIdx_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) {
@@ -3631,11 +3631,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_char_0 = 54;
+    private final static int mExportReduceIdx_my_half2_char_0 = 54;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_char_0(short[] in1, byte[] in2) {
@@ -3699,11 +3699,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_char_1 = 55;
+    private final static int mExportReduceIdx_my_half2_char_1 = 55;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_char_1(short[] in1, byte[] in2) {
@@ -3767,11 +3767,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_char2_0 = 56;
+    private final static int mExportReduceIdx_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) {
@@ -3839,11 +3839,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_char2_1 = 57;
+    private final static int mExportReduceIdx_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) {
@@ -3911,11 +3911,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_char4_0 = 58;
+    private final static int mExportReduceIdx_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) {
@@ -3983,11 +3983,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_char4_1 = 59;
+    private final static int mExportReduceIdx_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) {
@@ -4055,11 +4055,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_short_0 = 60;
+    private final static int mExportReduceIdx_my_half2_short_0 = 60;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_short_0(short[] in1, short[] in2) {
@@ -4123,11 +4123,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_short_1 = 61;
+    private final static int mExportReduceIdx_my_half2_short_1 = 61;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_short_1(short[] in1, short[] in2) {
@@ -4191,11 +4191,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_short2_0 = 62;
+    private final static int mExportReduceIdx_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) {
@@ -4263,11 +4263,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_short2_1 = 63;
+    private final static int mExportReduceIdx_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) {
@@ -4335,11 +4335,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_short4_0 = 64;
+    private final static int mExportReduceIdx_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) {
@@ -4407,11 +4407,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_short4_1 = 65;
+    private final static int mExportReduceIdx_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) {
@@ -4479,11 +4479,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_uchar_0 = 66;
+    private final static int mExportReduceIdx_my_half2_uchar_0 = 66;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_uchar_0(short[] in1, byte[] in2) {
@@ -4547,11 +4547,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_uchar_1 = 67;
+    private final static int mExportReduceIdx_my_half2_uchar_1 = 67;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_uchar_1(short[] in1, byte[] in2) {
@@ -4615,11 +4615,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_uchar2_0 = 68;
+    private final static int mExportReduceIdx_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) {
@@ -4687,11 +4687,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_uchar2_1 = 69;
+    private final static int mExportReduceIdx_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) {
@@ -4759,11 +4759,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_uchar4_0 = 70;
+    private final static int mExportReduceIdx_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) {
@@ -4831,11 +4831,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_uchar4_1 = 71;
+    private final static int mExportReduceIdx_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) {
@@ -4903,11 +4903,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_ushort_0 = 72;
+    private final static int mExportReduceIdx_my_half2_ushort_0 = 72;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_ushort_0(short[] in1, short[] in2) {
@@ -4971,11 +4971,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_ushort_1 = 73;
+    private final static int mExportReduceIdx_my_half2_ushort_1 = 73;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_ushort_1(short[] in1, short[] in2) {
@@ -5039,11 +5039,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_ushort2_0 = 74;
+    private final static int mExportReduceIdx_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) {
@@ -5111,11 +5111,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_ushort2_1 = 75;
+    private final static int mExportReduceIdx_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) {
@@ -5183,11 +5183,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_ushort4_0 = 76;
+    private final static int mExportReduceIdx_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) {
@@ -5255,11 +5255,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_ushort4_1 = 77;
+    private final static int mExportReduceIdx_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) {
@@ -5327,11 +5327,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_bool_0 = 78;
+    private final static int mExportReduceIdx_my_half2_bool_0 = 78;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_bool_0(short[] in1, byte[] in2) {
@@ -5395,11 +5395,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_bool_1 = 79;
+    private final static int mExportReduceIdx_my_half2_bool_1 = 79;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_half2_bool_1(short[] in1, byte[] in2) {
@@ -5463,11 +5463,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_rs_matrix2x2_0 = 80;
+    private final static int mExportReduceIdx_my_half2_rs_matrix2x2_0 = 80;
     // ain1 = "half2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_half2_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -5497,11 +5497,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_rs_matrix2x2_1 = 81;
+    private final static int mExportReduceIdx_my_half2_rs_matrix2x2_1 = 81;
     // ain1 = "half2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_half2_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -5531,11 +5531,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_MyStruct_0 = 82;
+    private final static int mExportReduceIdx_my_half2_MyStruct_0 = 82;
     // ain1 = "half2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_half2_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -5568,11 +5568,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2_MyStruct_1 = 83;
+    private final static int mExportReduceIdx_my_half2_MyStruct_1 = 83;
     // ain1 = "half2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_half2_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -5605,11 +5605,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_half_0 = 84;
+    private final static int mExportReduceIdx_my_half4_half_0 = 84;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_half_0(short[] in1, short[] in2) {
@@ -5673,11 +5673,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_half_1 = 85;
+    private final static int mExportReduceIdx_my_half4_half_1 = 85;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_half_1(short[] in1, short[] in2) {
@@ -5741,11 +5741,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_half2_0 = 86;
+    private final static int mExportReduceIdx_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) {
@@ -5813,11 +5813,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_half2_1 = 87;
+    private final static int mExportReduceIdx_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) {
@@ -5885,11 +5885,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_half4_0 = 88;
+    private final static int mExportReduceIdx_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) {
@@ -5957,11 +5957,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_half4_1 = 89;
+    private final static int mExportReduceIdx_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) {
@@ -6029,11 +6029,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_float_0 = 90;
+    private final static int mExportReduceIdx_my_half4_float_0 = 90;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_float_0(short[] in1, float[] in2) {
@@ -6097,11 +6097,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_float_1 = 91;
+    private final static int mExportReduceIdx_my_half4_float_1 = 91;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_float_1(short[] in1, float[] in2) {
@@ -6165,11 +6165,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_float2_0 = 92;
+    private final static int mExportReduceIdx_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) {
@@ -6237,11 +6237,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_float2_1 = 93;
+    private final static int mExportReduceIdx_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) {
@@ -6309,11 +6309,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_float4_0 = 94;
+    private final static int mExportReduceIdx_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) {
@@ -6381,11 +6381,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_float4_1 = 95;
+    private final static int mExportReduceIdx_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) {
@@ -6453,11 +6453,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_char_0 = 96;
+    private final static int mExportReduceIdx_my_half4_char_0 = 96;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_char_0(short[] in1, byte[] in2) {
@@ -6521,11 +6521,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_char_1 = 97;
+    private final static int mExportReduceIdx_my_half4_char_1 = 97;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_char_1(short[] in1, byte[] in2) {
@@ -6589,11 +6589,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_char2_0 = 98;
+    private final static int mExportReduceIdx_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) {
@@ -6661,11 +6661,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_char2_1 = 99;
+    private final static int mExportReduceIdx_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) {
@@ -6733,11 +6733,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_char4_0 = 100;
+    private final static int mExportReduceIdx_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) {
@@ -6805,11 +6805,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_char4_1 = 101;
+    private final static int mExportReduceIdx_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) {
@@ -6877,11 +6877,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_short_0 = 102;
+    private final static int mExportReduceIdx_my_half4_short_0 = 102;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_short_0(short[] in1, short[] in2) {
@@ -6945,11 +6945,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_short_1 = 103;
+    private final static int mExportReduceIdx_my_half4_short_1 = 103;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_short_1(short[] in1, short[] in2) {
@@ -7013,11 +7013,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_short2_0 = 104;
+    private final static int mExportReduceIdx_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) {
@@ -7085,11 +7085,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_short2_1 = 105;
+    private final static int mExportReduceIdx_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) {
@@ -7157,11 +7157,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_short4_0 = 106;
+    private final static int mExportReduceIdx_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) {
@@ -7229,11 +7229,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_short4_1 = 107;
+    private final static int mExportReduceIdx_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) {
@@ -7301,11 +7301,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_uchar_0 = 108;
+    private final static int mExportReduceIdx_my_half4_uchar_0 = 108;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_uchar_0(short[] in1, byte[] in2) {
@@ -7369,11 +7369,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_uchar_1 = 109;
+    private final static int mExportReduceIdx_my_half4_uchar_1 = 109;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_uchar_1(short[] in1, byte[] in2) {
@@ -7437,11 +7437,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_uchar2_0 = 110;
+    private final static int mExportReduceIdx_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) {
@@ -7509,11 +7509,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_uchar2_1 = 111;
+    private final static int mExportReduceIdx_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) {
@@ -7581,11 +7581,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_uchar4_0 = 112;
+    private final static int mExportReduceIdx_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) {
@@ -7653,11 +7653,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_uchar4_1 = 113;
+    private final static int mExportReduceIdx_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) {
@@ -7725,11 +7725,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_ushort_0 = 114;
+    private final static int mExportReduceIdx_my_half4_ushort_0 = 114;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_ushort_0(short[] in1, short[] in2) {
@@ -7793,11 +7793,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_ushort_1 = 115;
+    private final static int mExportReduceIdx_my_half4_ushort_1 = 115;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_ushort_1(short[] in1, short[] in2) {
@@ -7861,11 +7861,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_ushort2_0 = 116;
+    private final static int mExportReduceIdx_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) {
@@ -7933,11 +7933,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_ushort2_1 = 117;
+    private final static int mExportReduceIdx_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) {
@@ -8005,11 +8005,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_ushort4_0 = 118;
+    private final static int mExportReduceIdx_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) {
@@ -8077,11 +8077,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_ushort4_1 = 119;
+    private final static int mExportReduceIdx_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) {
@@ -8149,11 +8149,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_bool_0 = 120;
+    private final static int mExportReduceIdx_my_half4_bool_0 = 120;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_bool_0(short[] in1, byte[] in2) {
@@ -8217,11 +8217,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_bool_1 = 121;
+    private final static int mExportReduceIdx_my_half4_bool_1 = 121;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_half4_bool_1(short[] in1, byte[] in2) {
@@ -8285,11 +8285,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_rs_matrix2x2_0 = 122;
+    private final static int mExportReduceIdx_my_half4_rs_matrix2x2_0 = 122;
     // ain1 = "half4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_half4_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -8319,11 +8319,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_rs_matrix2x2_1 = 123;
+    private final static int mExportReduceIdx_my_half4_rs_matrix2x2_1 = 123;
     // ain1 = "half4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_half4_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -8353,11 +8353,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_MyStruct_0 = 124;
+    private final static int mExportReduceIdx_my_half4_MyStruct_0 = 124;
     // ain1 = "half4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_half4_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -8390,11 +8390,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4_MyStruct_1 = 125;
+    private final static int mExportReduceIdx_my_half4_MyStruct_1 = 125;
     // ain1 = "half4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_half4_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -8427,11 +8427,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_half4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_half_0 = 126;
+    private final static int mExportReduceIdx_my_float_half_0 = 126;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_half_0(float[] in1, short[] in2) {
@@ -8491,11 +8491,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_half_1 = 127;
+    private final static int mExportReduceIdx_my_float_half_1 = 127;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_half_1(float[] in1, short[] in2) {
@@ -8555,11 +8555,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_half2_0 = 128;
+    private final static int mExportReduceIdx_my_float_half2_0 = 128;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_half2_0(float[] in1, short[] in2) {
@@ -8623,11 +8623,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_half2_1 = 129;
+    private final static int mExportReduceIdx_my_float_half2_1 = 129;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_half2_1(float[] in1, short[] in2) {
@@ -8691,11 +8691,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_half4_0 = 130;
+    private final static int mExportReduceIdx_my_float_half4_0 = 130;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_half4_0(float[] in1, short[] in2) {
@@ -8759,11 +8759,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_half4_1 = 131;
+    private final static int mExportReduceIdx_my_float_half4_1 = 131;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_half4_1(float[] in1, short[] in2) {
@@ -8827,11 +8827,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_float_0 = 132;
+    private final static int mExportReduceIdx_my_float_float_0 = 132;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_float_0(float[] in1, float[] in2) {
@@ -8891,11 +8891,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_float_1 = 133;
+    private final static int mExportReduceIdx_my_float_float_1 = 133;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_float_1(float[] in1, float[] in2) {
@@ -8955,11 +8955,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_float2_0 = 134;
+    private final static int mExportReduceIdx_my_float_float2_0 = 134;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_float2_0(float[] in1, float[] in2) {
@@ -9023,11 +9023,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_float2_1 = 135;
+    private final static int mExportReduceIdx_my_float_float2_1 = 135;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_float2_1(float[] in1, float[] in2) {
@@ -9091,11 +9091,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_float4_0 = 136;
+    private final static int mExportReduceIdx_my_float_float4_0 = 136;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_float4_0(float[] in1, float[] in2) {
@@ -9159,11 +9159,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_float4_1 = 137;
+    private final static int mExportReduceIdx_my_float_float4_1 = 137;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_float4_1(float[] in1, float[] in2) {
@@ -9227,11 +9227,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_char_0 = 138;
+    private final static int mExportReduceIdx_my_float_char_0 = 138;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_char_0(float[] in1, byte[] in2) {
@@ -9291,11 +9291,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_char_1 = 139;
+    private final static int mExportReduceIdx_my_float_char_1 = 139;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_char_1(float[] in1, byte[] in2) {
@@ -9355,11 +9355,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_char2_0 = 140;
+    private final static int mExportReduceIdx_my_float_char2_0 = 140;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_char2_0(float[] in1, byte[] in2) {
@@ -9423,11 +9423,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_char2_1 = 141;
+    private final static int mExportReduceIdx_my_float_char2_1 = 141;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_char2_1(float[] in1, byte[] in2) {
@@ -9491,11 +9491,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_char4_0 = 142;
+    private final static int mExportReduceIdx_my_float_char4_0 = 142;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_char4_0(float[] in1, byte[] in2) {
@@ -9559,11 +9559,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_char4_1 = 143;
+    private final static int mExportReduceIdx_my_float_char4_1 = 143;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_char4_1(float[] in1, byte[] in2) {
@@ -9627,11 +9627,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_short_0 = 144;
+    private final static int mExportReduceIdx_my_float_short_0 = 144;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_short_0(float[] in1, short[] in2) {
@@ -9691,11 +9691,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_short_1 = 145;
+    private final static int mExportReduceIdx_my_float_short_1 = 145;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_short_1(float[] in1, short[] in2) {
@@ -9755,11 +9755,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_short2_0 = 146;
+    private final static int mExportReduceIdx_my_float_short2_0 = 146;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_short2_0(float[] in1, short[] in2) {
@@ -9823,11 +9823,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_short2_1 = 147;
+    private final static int mExportReduceIdx_my_float_short2_1 = 147;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_short2_1(float[] in1, short[] in2) {
@@ -9891,11 +9891,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_short4_0 = 148;
+    private final static int mExportReduceIdx_my_float_short4_0 = 148;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_short4_0(float[] in1, short[] in2) {
@@ -9959,11 +9959,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_short4_1 = 149;
+    private final static int mExportReduceIdx_my_float_short4_1 = 149;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_short4_1(float[] in1, short[] in2) {
@@ -10027,11 +10027,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_uchar_0 = 150;
+    private final static int mExportReduceIdx_my_float_uchar_0 = 150;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_uchar_0(float[] in1, byte[] in2) {
@@ -10091,11 +10091,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_uchar_1 = 151;
+    private final static int mExportReduceIdx_my_float_uchar_1 = 151;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_uchar_1(float[] in1, byte[] in2) {
@@ -10155,11 +10155,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_uchar2_0 = 152;
+    private final static int mExportReduceIdx_my_float_uchar2_0 = 152;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_uchar2_0(float[] in1, byte[] in2) {
@@ -10223,11 +10223,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_uchar2_1 = 153;
+    private final static int mExportReduceIdx_my_float_uchar2_1 = 153;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_uchar2_1(float[] in1, byte[] in2) {
@@ -10291,11 +10291,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_uchar4_0 = 154;
+    private final static int mExportReduceIdx_my_float_uchar4_0 = 154;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_uchar4_0(float[] in1, byte[] in2) {
@@ -10359,11 +10359,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_uchar4_1 = 155;
+    private final static int mExportReduceIdx_my_float_uchar4_1 = 155;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_uchar4_1(float[] in1, byte[] in2) {
@@ -10427,11 +10427,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_ushort_0 = 156;
+    private final static int mExportReduceIdx_my_float_ushort_0 = 156;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_ushort_0(float[] in1, short[] in2) {
@@ -10491,11 +10491,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_ushort_1 = 157;
+    private final static int mExportReduceIdx_my_float_ushort_1 = 157;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_ushort_1(float[] in1, short[] in2) {
@@ -10555,11 +10555,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_ushort2_0 = 158;
+    private final static int mExportReduceIdx_my_float_ushort2_0 = 158;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_ushort2_0(float[] in1, short[] in2) {
@@ -10623,11 +10623,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_ushort2_1 = 159;
+    private final static int mExportReduceIdx_my_float_ushort2_1 = 159;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float_ushort2_1(float[] in1, short[] in2) {
@@ -10691,11 +10691,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_ushort4_0 = 160;
+    private final static int mExportReduceIdx_my_float_ushort4_0 = 160;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_ushort4_0(float[] in1, short[] in2) {
@@ -10759,11 +10759,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_ushort4_1 = 161;
+    private final static int mExportReduceIdx_my_float_ushort4_1 = 161;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float_ushort4_1(float[] in1, short[] in2) {
@@ -10827,11 +10827,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_bool_0 = 162;
+    private final static int mExportReduceIdx_my_float_bool_0 = 162;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_bool_0(float[] in1, byte[] in2) {
@@ -10891,11 +10891,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_bool_1 = 163;
+    private final static int mExportReduceIdx_my_float_bool_1 = 163;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_float_bool_1(float[] in1, byte[] in2) {
@@ -10955,11 +10955,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_rs_matrix2x2_0 = 164;
+    private final static int mExportReduceIdx_my_float_rs_matrix2x2_0 = 164;
     // ain1 = "float a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_float_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -10989,11 +10989,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_rs_matrix2x2_1 = 165;
+    private final static int mExportReduceIdx_my_float_rs_matrix2x2_1 = 165;
     // ain1 = "float a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_float_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -11023,11 +11023,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_MyStruct_0 = 166;
+    private final static int mExportReduceIdx_my_float_MyStruct_0 = 166;
     // ain1 = "float a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_float_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -11060,11 +11060,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float_MyStruct_1 = 167;
+    private final static int mExportReduceIdx_my_float_MyStruct_1 = 167;
     // ain1 = "float a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_float_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -11097,11 +11097,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_half_0 = 168;
+    private final static int mExportReduceIdx_my_float2_half_0 = 168;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_half_0(float[] in1, short[] in2) {
@@ -11165,11 +11165,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_half_1 = 169;
+    private final static int mExportReduceIdx_my_float2_half_1 = 169;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_half_1(float[] in1, short[] in2) {
@@ -11233,11 +11233,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_half2_0 = 170;
+    private final static int mExportReduceIdx_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) {
@@ -11305,11 +11305,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_half2_1 = 171;
+    private final static int mExportReduceIdx_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) {
@@ -11377,11 +11377,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_half4_0 = 172;
+    private final static int mExportReduceIdx_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) {
@@ -11449,11 +11449,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_half4_1 = 173;
+    private final static int mExportReduceIdx_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) {
@@ -11521,11 +11521,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_float_0 = 174;
+    private final static int mExportReduceIdx_my_float2_float_0 = 174;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_float_0(float[] in1, float[] in2) {
@@ -11589,11 +11589,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_float_1 = 175;
+    private final static int mExportReduceIdx_my_float2_float_1 = 175;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_float_1(float[] in1, float[] in2) {
@@ -11657,11 +11657,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_float2_0 = 176;
+    private final static int mExportReduceIdx_my_float2_float2_0 = 176;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_float2_0(float[] in1, float[] in2) {
@@ -11729,11 +11729,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_float2_1 = 177;
+    private final static int mExportReduceIdx_my_float2_float2_1 = 177;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_float2_1(float[] in1, float[] in2) {
@@ -11801,11 +11801,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_float4_0 = 178;
+    private final static int mExportReduceIdx_my_float2_float4_0 = 178;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_float4_0(float[] in1, float[] in2) {
@@ -11873,11 +11873,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_float4_1 = 179;
+    private final static int mExportReduceIdx_my_float2_float4_1 = 179;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_float4_1(float[] in1, float[] in2) {
@@ -11945,11 +11945,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_char_0 = 180;
+    private final static int mExportReduceIdx_my_float2_char_0 = 180;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_char_0(float[] in1, byte[] in2) {
@@ -12013,11 +12013,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_char_1 = 181;
+    private final static int mExportReduceIdx_my_float2_char_1 = 181;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_char_1(float[] in1, byte[] in2) {
@@ -12081,11 +12081,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_char2_0 = 182;
+    private final static int mExportReduceIdx_my_float2_char2_0 = 182;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_char2_0(float[] in1, byte[] in2) {
@@ -12153,11 +12153,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_char2_1 = 183;
+    private final static int mExportReduceIdx_my_float2_char2_1 = 183;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_char2_1(float[] in1, byte[] in2) {
@@ -12225,11 +12225,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_char4_0 = 184;
+    private final static int mExportReduceIdx_my_float2_char4_0 = 184;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_char4_0(float[] in1, byte[] in2) {
@@ -12297,11 +12297,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_char4_1 = 185;
+    private final static int mExportReduceIdx_my_float2_char4_1 = 185;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_char4_1(float[] in1, byte[] in2) {
@@ -12369,11 +12369,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_short_0 = 186;
+    private final static int mExportReduceIdx_my_float2_short_0 = 186;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_short_0(float[] in1, short[] in2) {
@@ -12437,11 +12437,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_short_1 = 187;
+    private final static int mExportReduceIdx_my_float2_short_1 = 187;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_short_1(float[] in1, short[] in2) {
@@ -12505,11 +12505,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_short2_0 = 188;
+    private final static int mExportReduceIdx_my_float2_short2_0 = 188;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_short2_0(float[] in1, short[] in2) {
@@ -12577,11 +12577,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_short2_1 = 189;
+    private final static int mExportReduceIdx_my_float2_short2_1 = 189;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_short2_1(float[] in1, short[] in2) {
@@ -12649,11 +12649,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_short4_0 = 190;
+    private final static int mExportReduceIdx_my_float2_short4_0 = 190;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_short4_0(float[] in1, short[] in2) {
@@ -12721,11 +12721,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_short4_1 = 191;
+    private final static int mExportReduceIdx_my_float2_short4_1 = 191;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_short4_1(float[] in1, short[] in2) {
@@ -12793,11 +12793,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_uchar_0 = 192;
+    private final static int mExportReduceIdx_my_float2_uchar_0 = 192;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_uchar_0(float[] in1, byte[] in2) {
@@ -12861,11 +12861,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_uchar_1 = 193;
+    private final static int mExportReduceIdx_my_float2_uchar_1 = 193;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_uchar_1(float[] in1, byte[] in2) {
@@ -12929,11 +12929,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_uchar2_0 = 194;
+    private final static int mExportReduceIdx_my_float2_uchar2_0 = 194;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_uchar2_0(float[] in1, byte[] in2) {
@@ -13001,11 +13001,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_uchar2_1 = 195;
+    private final static int mExportReduceIdx_my_float2_uchar2_1 = 195;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_uchar2_1(float[] in1, byte[] in2) {
@@ -13073,11 +13073,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_uchar4_0 = 196;
+    private final static int mExportReduceIdx_my_float2_uchar4_0 = 196;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_uchar4_0(float[] in1, byte[] in2) {
@@ -13145,11 +13145,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_uchar4_1 = 197;
+    private final static int mExportReduceIdx_my_float2_uchar4_1 = 197;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_uchar4_1(float[] in1, byte[] in2) {
@@ -13217,11 +13217,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_ushort_0 = 198;
+    private final static int mExportReduceIdx_my_float2_ushort_0 = 198;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_ushort_0(float[] in1, short[] in2) {
@@ -13285,11 +13285,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_ushort_1 = 199;
+    private final static int mExportReduceIdx_my_float2_ushort_1 = 199;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_ushort_1(float[] in1, short[] in2) {
@@ -13353,11 +13353,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_ushort2_0 = 200;
+    private final static int mExportReduceIdx_my_float2_ushort2_0 = 200;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_ushort2_0(float[] in1, short[] in2) {
@@ -13425,11 +13425,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_ushort2_1 = 201;
+    private final static int mExportReduceIdx_my_float2_ushort2_1 = 201;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float2_ushort2_1(float[] in1, short[] in2) {
@@ -13497,11 +13497,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_ushort4_0 = 202;
+    private final static int mExportReduceIdx_my_float2_ushort4_0 = 202;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_ushort4_0(float[] in1, short[] in2) {
@@ -13569,11 +13569,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_ushort4_1 = 203;
+    private final static int mExportReduceIdx_my_float2_ushort4_1 = 203;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float2_ushort4_1(float[] in1, short[] in2) {
@@ -13641,11 +13641,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_bool_0 = 204;
+    private final static int mExportReduceIdx_my_float2_bool_0 = 204;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_bool_0(float[] in1, byte[] in2) {
@@ -13709,11 +13709,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_bool_1 = 205;
+    private final static int mExportReduceIdx_my_float2_bool_1 = 205;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_float2_bool_1(float[] in1, byte[] in2) {
@@ -13777,11 +13777,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_rs_matrix2x2_0 = 206;
+    private final static int mExportReduceIdx_my_float2_rs_matrix2x2_0 = 206;
     // ain1 = "float2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_float2_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -13811,11 +13811,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_rs_matrix2x2_1 = 207;
+    private final static int mExportReduceIdx_my_float2_rs_matrix2x2_1 = 207;
     // ain1 = "float2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_float2_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -13845,11 +13845,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_MyStruct_0 = 208;
+    private final static int mExportReduceIdx_my_float2_MyStruct_0 = 208;
     // ain1 = "float2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_float2_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -13882,11 +13882,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2_MyStruct_1 = 209;
+    private final static int mExportReduceIdx_my_float2_MyStruct_1 = 209;
     // ain1 = "float2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_float2_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -13919,11 +13919,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_half_0 = 210;
+    private final static int mExportReduceIdx_my_float4_half_0 = 210;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_half_0(float[] in1, short[] in2) {
@@ -13987,11 +13987,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_half_1 = 211;
+    private final static int mExportReduceIdx_my_float4_half_1 = 211;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_half_1(float[] in1, short[] in2) {
@@ -14055,11 +14055,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_half2_0 = 212;
+    private final static int mExportReduceIdx_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) {
@@ -14127,11 +14127,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_half2_1 = 213;
+    private final static int mExportReduceIdx_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) {
@@ -14199,11 +14199,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_half4_0 = 214;
+    private final static int mExportReduceIdx_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) {
@@ -14271,11 +14271,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_half4_1 = 215;
+    private final static int mExportReduceIdx_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) {
@@ -14343,11 +14343,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_float_0 = 216;
+    private final static int mExportReduceIdx_my_float4_float_0 = 216;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_float_0(float[] in1, float[] in2) {
@@ -14411,11 +14411,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_float_1 = 217;
+    private final static int mExportReduceIdx_my_float4_float_1 = 217;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_float_1(float[] in1, float[] in2) {
@@ -14479,11 +14479,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_float2_0 = 218;
+    private final static int mExportReduceIdx_my_float4_float2_0 = 218;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_float2_0(float[] in1, float[] in2) {
@@ -14551,11 +14551,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_float2_1 = 219;
+    private final static int mExportReduceIdx_my_float4_float2_1 = 219;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_float2_1(float[] in1, float[] in2) {
@@ -14623,11 +14623,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_float4_0 = 220;
+    private final static int mExportReduceIdx_my_float4_float4_0 = 220;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_float4_0(float[] in1, float[] in2) {
@@ -14695,11 +14695,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_float4_1 = 221;
+    private final static int mExportReduceIdx_my_float4_float4_1 = 221;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_float4_1(float[] in1, float[] in2) {
@@ -14767,11 +14767,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_char_0 = 222;
+    private final static int mExportReduceIdx_my_float4_char_0 = 222;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_char_0(float[] in1, byte[] in2) {
@@ -14835,11 +14835,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_char_1 = 223;
+    private final static int mExportReduceIdx_my_float4_char_1 = 223;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_char_1(float[] in1, byte[] in2) {
@@ -14903,11 +14903,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_char2_0 = 224;
+    private final static int mExportReduceIdx_my_float4_char2_0 = 224;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_char2_0(float[] in1, byte[] in2) {
@@ -14975,11 +14975,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_char2_1 = 225;
+    private final static int mExportReduceIdx_my_float4_char2_1 = 225;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_char2_1(float[] in1, byte[] in2) {
@@ -15047,11 +15047,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_char4_0 = 226;
+    private final static int mExportReduceIdx_my_float4_char4_0 = 226;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_char4_0(float[] in1, byte[] in2) {
@@ -15119,11 +15119,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_char4_1 = 227;
+    private final static int mExportReduceIdx_my_float4_char4_1 = 227;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_char4_1(float[] in1, byte[] in2) {
@@ -15191,11 +15191,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_short_0 = 228;
+    private final static int mExportReduceIdx_my_float4_short_0 = 228;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_short_0(float[] in1, short[] in2) {
@@ -15259,11 +15259,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_short_1 = 229;
+    private final static int mExportReduceIdx_my_float4_short_1 = 229;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_short_1(float[] in1, short[] in2) {
@@ -15327,11 +15327,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_short2_0 = 230;
+    private final static int mExportReduceIdx_my_float4_short2_0 = 230;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_short2_0(float[] in1, short[] in2) {
@@ -15399,11 +15399,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_short2_1 = 231;
+    private final static int mExportReduceIdx_my_float4_short2_1 = 231;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_short2_1(float[] in1, short[] in2) {
@@ -15471,11 +15471,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_short4_0 = 232;
+    private final static int mExportReduceIdx_my_float4_short4_0 = 232;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_short4_0(float[] in1, short[] in2) {
@@ -15543,11 +15543,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_short4_1 = 233;
+    private final static int mExportReduceIdx_my_float4_short4_1 = 233;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_short4_1(float[] in1, short[] in2) {
@@ -15615,11 +15615,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_uchar_0 = 234;
+    private final static int mExportReduceIdx_my_float4_uchar_0 = 234;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_uchar_0(float[] in1, byte[] in2) {
@@ -15683,11 +15683,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_uchar_1 = 235;
+    private final static int mExportReduceIdx_my_float4_uchar_1 = 235;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_uchar_1(float[] in1, byte[] in2) {
@@ -15751,11 +15751,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_uchar2_0 = 236;
+    private final static int mExportReduceIdx_my_float4_uchar2_0 = 236;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_uchar2_0(float[] in1, byte[] in2) {
@@ -15823,11 +15823,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_uchar2_1 = 237;
+    private final static int mExportReduceIdx_my_float4_uchar2_1 = 237;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_uchar2_1(float[] in1, byte[] in2) {
@@ -15895,11 +15895,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_uchar4_0 = 238;
+    private final static int mExportReduceIdx_my_float4_uchar4_0 = 238;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_uchar4_0(float[] in1, byte[] in2) {
@@ -15967,11 +15967,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_uchar4_1 = 239;
+    private final static int mExportReduceIdx_my_float4_uchar4_1 = 239;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_uchar4_1(float[] in1, byte[] in2) {
@@ -16039,11 +16039,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_ushort_0 = 240;
+    private final static int mExportReduceIdx_my_float4_ushort_0 = 240;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_ushort_0(float[] in1, short[] in2) {
@@ -16107,11 +16107,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_ushort_1 = 241;
+    private final static int mExportReduceIdx_my_float4_ushort_1 = 241;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_ushort_1(float[] in1, short[] in2) {
@@ -16175,11 +16175,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_ushort2_0 = 242;
+    private final static int mExportReduceIdx_my_float4_ushort2_0 = 242;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_ushort2_0(float[] in1, short[] in2) {
@@ -16247,11 +16247,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_ushort2_1 = 243;
+    private final static int mExportReduceIdx_my_float4_ushort2_1 = 243;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_float4_ushort2_1(float[] in1, short[] in2) {
@@ -16319,11 +16319,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_ushort4_0 = 244;
+    private final static int mExportReduceIdx_my_float4_ushort4_0 = 244;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_ushort4_0(float[] in1, short[] in2) {
@@ -16391,11 +16391,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_ushort4_1 = 245;
+    private final static int mExportReduceIdx_my_float4_ushort4_1 = 245;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_float4_ushort4_1(float[] in1, short[] in2) {
@@ -16463,11 +16463,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_bool_0 = 246;
+    private final static int mExportReduceIdx_my_float4_bool_0 = 246;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_bool_0(float[] in1, byte[] in2) {
@@ -16531,11 +16531,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_bool_1 = 247;
+    private final static int mExportReduceIdx_my_float4_bool_1 = 247;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_float4_bool_1(float[] in1, byte[] in2) {
@@ -16599,11 +16599,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_rs_matrix2x2_0 = 248;
+    private final static int mExportReduceIdx_my_float4_rs_matrix2x2_0 = 248;
     // ain1 = "float4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_float4_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -16633,11 +16633,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_rs_matrix2x2_1 = 249;
+    private final static int mExportReduceIdx_my_float4_rs_matrix2x2_1 = 249;
     // ain1 = "float4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_float4_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -16667,11 +16667,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_MyStruct_0 = 250;
+    private final static int mExportReduceIdx_my_float4_MyStruct_0 = 250;
     // ain1 = "float4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_float4_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -16704,11 +16704,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4_MyStruct_1 = 251;
+    private final static int mExportReduceIdx_my_float4_MyStruct_1 = 251;
     // ain1 = "float4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_float4_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -16741,11 +16741,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_float4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_half_0 = 252;
+    private final static int mExportReduceIdx_my_char_half_0 = 252;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_half_0(byte[] in1, short[] in2) {
@@ -16805,11 +16805,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_half_1 = 253;
+    private final static int mExportReduceIdx_my_char_half_1 = 253;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_half_1(byte[] in1, short[] in2) {
@@ -16869,11 +16869,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_half2_0 = 254;
+    private final static int mExportReduceIdx_my_char_half2_0 = 254;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_half2_0(byte[] in1, short[] in2) {
@@ -16937,11 +16937,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_half2_1 = 255;
+    private final static int mExportReduceIdx_my_char_half2_1 = 255;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_half2_1(byte[] in1, short[] in2) {
@@ -17005,11 +17005,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_half4_0 = 256;
+    private final static int mExportReduceIdx_my_char_half4_0 = 256;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_half4_0(byte[] in1, short[] in2) {
@@ -17073,11 +17073,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_half4_1 = 257;
+    private final static int mExportReduceIdx_my_char_half4_1 = 257;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_half4_1(byte[] in1, short[] in2) {
@@ -17141,11 +17141,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_float_0 = 258;
+    private final static int mExportReduceIdx_my_char_float_0 = 258;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_float_0(byte[] in1, float[] in2) {
@@ -17205,11 +17205,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_float_1 = 259;
+    private final static int mExportReduceIdx_my_char_float_1 = 259;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_float_1(byte[] in1, float[] in2) {
@@ -17269,11 +17269,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_float2_0 = 260;
+    private final static int mExportReduceIdx_my_char_float2_0 = 260;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_float2_0(byte[] in1, float[] in2) {
@@ -17337,11 +17337,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_float2_1 = 261;
+    private final static int mExportReduceIdx_my_char_float2_1 = 261;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_float2_1(byte[] in1, float[] in2) {
@@ -17405,11 +17405,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_float4_0 = 262;
+    private final static int mExportReduceIdx_my_char_float4_0 = 262;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_float4_0(byte[] in1, float[] in2) {
@@ -17473,11 +17473,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_float4_1 = 263;
+    private final static int mExportReduceIdx_my_char_float4_1 = 263;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_float4_1(byte[] in1, float[] in2) {
@@ -17541,11 +17541,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_char_0 = 264;
+    private final static int mExportReduceIdx_my_char_char_0 = 264;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_char_0(byte[] in1, byte[] in2) {
@@ -17605,11 +17605,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_char_1 = 265;
+    private final static int mExportReduceIdx_my_char_char_1 = 265;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_char_1(byte[] in1, byte[] in2) {
@@ -17669,11 +17669,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_char2_0 = 266;
+    private final static int mExportReduceIdx_my_char_char2_0 = 266;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_char2_0(byte[] in1, byte[] in2) {
@@ -17737,11 +17737,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_char2_1 = 267;
+    private final static int mExportReduceIdx_my_char_char2_1 = 267;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_char2_1(byte[] in1, byte[] in2) {
@@ -17805,11 +17805,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_char4_0 = 268;
+    private final static int mExportReduceIdx_my_char_char4_0 = 268;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_char4_0(byte[] in1, byte[] in2) {
@@ -17873,11 +17873,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_char4_1 = 269;
+    private final static int mExportReduceIdx_my_char_char4_1 = 269;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_char4_1(byte[] in1, byte[] in2) {
@@ -17941,11 +17941,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_short_0 = 270;
+    private final static int mExportReduceIdx_my_char_short_0 = 270;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_short_0(byte[] in1, short[] in2) {
@@ -18005,11 +18005,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_short_1 = 271;
+    private final static int mExportReduceIdx_my_char_short_1 = 271;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_short_1(byte[] in1, short[] in2) {
@@ -18069,11 +18069,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_short2_0 = 272;
+    private final static int mExportReduceIdx_my_char_short2_0 = 272;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_short2_0(byte[] in1, short[] in2) {
@@ -18137,11 +18137,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_short2_1 = 273;
+    private final static int mExportReduceIdx_my_char_short2_1 = 273;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_short2_1(byte[] in1, short[] in2) {
@@ -18205,11 +18205,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_short4_0 = 274;
+    private final static int mExportReduceIdx_my_char_short4_0 = 274;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_short4_0(byte[] in1, short[] in2) {
@@ -18273,11 +18273,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_short4_1 = 275;
+    private final static int mExportReduceIdx_my_char_short4_1 = 275;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_short4_1(byte[] in1, short[] in2) {
@@ -18341,11 +18341,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_uchar_0 = 276;
+    private final static int mExportReduceIdx_my_char_uchar_0 = 276;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_uchar_0(byte[] in1, byte[] in2) {
@@ -18405,11 +18405,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_uchar_1 = 277;
+    private final static int mExportReduceIdx_my_char_uchar_1 = 277;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_uchar_1(byte[] in1, byte[] in2) {
@@ -18469,11 +18469,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_uchar2_0 = 278;
+    private final static int mExportReduceIdx_my_char_uchar2_0 = 278;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_uchar2_0(byte[] in1, byte[] in2) {
@@ -18537,11 +18537,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_uchar2_1 = 279;
+    private final static int mExportReduceIdx_my_char_uchar2_1 = 279;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_uchar2_1(byte[] in1, byte[] in2) {
@@ -18605,11 +18605,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_uchar4_0 = 280;
+    private final static int mExportReduceIdx_my_char_uchar4_0 = 280;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_uchar4_0(byte[] in1, byte[] in2) {
@@ -18673,11 +18673,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_uchar4_1 = 281;
+    private final static int mExportReduceIdx_my_char_uchar4_1 = 281;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_uchar4_1(byte[] in1, byte[] in2) {
@@ -18741,11 +18741,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_ushort_0 = 282;
+    private final static int mExportReduceIdx_my_char_ushort_0 = 282;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_ushort_0(byte[] in1, short[] in2) {
@@ -18805,11 +18805,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_ushort_1 = 283;
+    private final static int mExportReduceIdx_my_char_ushort_1 = 283;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_ushort_1(byte[] in1, short[] in2) {
@@ -18869,11 +18869,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_ushort2_0 = 284;
+    private final static int mExportReduceIdx_my_char_ushort2_0 = 284;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_ushort2_0(byte[] in1, short[] in2) {
@@ -18937,11 +18937,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_ushort2_1 = 285;
+    private final static int mExportReduceIdx_my_char_ushort2_1 = 285;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char_ushort2_1(byte[] in1, short[] in2) {
@@ -19005,11 +19005,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_ushort4_0 = 286;
+    private final static int mExportReduceIdx_my_char_ushort4_0 = 286;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_ushort4_0(byte[] in1, short[] in2) {
@@ -19073,11 +19073,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_ushort4_1 = 287;
+    private final static int mExportReduceIdx_my_char_ushort4_1 = 287;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char_ushort4_1(byte[] in1, short[] in2) {
@@ -19141,11 +19141,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_bool_0 = 288;
+    private final static int mExportReduceIdx_my_char_bool_0 = 288;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_bool_0(byte[] in1, byte[] in2) {
@@ -19205,11 +19205,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_bool_1 = 289;
+    private final static int mExportReduceIdx_my_char_bool_1 = 289;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_char_bool_1(byte[] in1, byte[] in2) {
@@ -19269,11 +19269,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_rs_matrix2x2_0 = 290;
+    private final static int mExportReduceIdx_my_char_rs_matrix2x2_0 = 290;
     // ain1 = "char a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_char_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -19303,11 +19303,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_rs_matrix2x2_1 = 291;
+    private final static int mExportReduceIdx_my_char_rs_matrix2x2_1 = 291;
     // ain1 = "char a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_char_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -19337,11 +19337,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_MyStruct_0 = 292;
+    private final static int mExportReduceIdx_my_char_MyStruct_0 = 292;
     // ain1 = "char a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_char_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -19374,11 +19374,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char_MyStruct_1 = 293;
+    private final static int mExportReduceIdx_my_char_MyStruct_1 = 293;
     // ain1 = "char a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_char_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -19411,11 +19411,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_half_0 = 294;
+    private final static int mExportReduceIdx_my_char2_half_0 = 294;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_half_0(byte[] in1, short[] in2) {
@@ -19479,11 +19479,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_half_1 = 295;
+    private final static int mExportReduceIdx_my_char2_half_1 = 295;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_half_1(byte[] in1, short[] in2) {
@@ -19547,11 +19547,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_half2_0 = 296;
+    private final static int mExportReduceIdx_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) {
@@ -19619,11 +19619,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_half2_1 = 297;
+    private final static int mExportReduceIdx_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) {
@@ -19691,11 +19691,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_half4_0 = 298;
+    private final static int mExportReduceIdx_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) {
@@ -19763,11 +19763,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_half4_1 = 299;
+    private final static int mExportReduceIdx_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) {
@@ -19835,11 +19835,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_float_0 = 300;
+    private final static int mExportReduceIdx_my_char2_float_0 = 300;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_float_0(byte[] in1, float[] in2) {
@@ -19903,11 +19903,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_float_1 = 301;
+    private final static int mExportReduceIdx_my_char2_float_1 = 301;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_float_1(byte[] in1, float[] in2) {
@@ -19971,11 +19971,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_float2_0 = 302;
+    private final static int mExportReduceIdx_my_char2_float2_0 = 302;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_float2_0(byte[] in1, float[] in2) {
@@ -20043,11 +20043,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_float2_1 = 303;
+    private final static int mExportReduceIdx_my_char2_float2_1 = 303;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_float2_1(byte[] in1, float[] in2) {
@@ -20115,11 +20115,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_float4_0 = 304;
+    private final static int mExportReduceIdx_my_char2_float4_0 = 304;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_float4_0(byte[] in1, float[] in2) {
@@ -20187,11 +20187,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_float4_1 = 305;
+    private final static int mExportReduceIdx_my_char2_float4_1 = 305;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_float4_1(byte[] in1, float[] in2) {
@@ -20259,11 +20259,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_char_0 = 306;
+    private final static int mExportReduceIdx_my_char2_char_0 = 306;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_char_0(byte[] in1, byte[] in2) {
@@ -20327,11 +20327,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_char_1 = 307;
+    private final static int mExportReduceIdx_my_char2_char_1 = 307;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_char_1(byte[] in1, byte[] in2) {
@@ -20395,11 +20395,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_char2_0 = 308;
+    private final static int mExportReduceIdx_my_char2_char2_0 = 308;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_char2_0(byte[] in1, byte[] in2) {
@@ -20467,11 +20467,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_char2_1 = 309;
+    private final static int mExportReduceIdx_my_char2_char2_1 = 309;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_char2_1(byte[] in1, byte[] in2) {
@@ -20539,11 +20539,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_char4_0 = 310;
+    private final static int mExportReduceIdx_my_char2_char4_0 = 310;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_char4_0(byte[] in1, byte[] in2) {
@@ -20611,11 +20611,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_char4_1 = 311;
+    private final static int mExportReduceIdx_my_char2_char4_1 = 311;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_char4_1(byte[] in1, byte[] in2) {
@@ -20683,11 +20683,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_short_0 = 312;
+    private final static int mExportReduceIdx_my_char2_short_0 = 312;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_short_0(byte[] in1, short[] in2) {
@@ -20751,11 +20751,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_short_1 = 313;
+    private final static int mExportReduceIdx_my_char2_short_1 = 313;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_short_1(byte[] in1, short[] in2) {
@@ -20819,11 +20819,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_short2_0 = 314;
+    private final static int mExportReduceIdx_my_char2_short2_0 = 314;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_short2_0(byte[] in1, short[] in2) {
@@ -20891,11 +20891,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_short2_1 = 315;
+    private final static int mExportReduceIdx_my_char2_short2_1 = 315;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_short2_1(byte[] in1, short[] in2) {
@@ -20963,11 +20963,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_short4_0 = 316;
+    private final static int mExportReduceIdx_my_char2_short4_0 = 316;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_short4_0(byte[] in1, short[] in2) {
@@ -21035,11 +21035,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_short4_1 = 317;
+    private final static int mExportReduceIdx_my_char2_short4_1 = 317;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_short4_1(byte[] in1, short[] in2) {
@@ -21107,11 +21107,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_uchar_0 = 318;
+    private final static int mExportReduceIdx_my_char2_uchar_0 = 318;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_uchar_0(byte[] in1, byte[] in2) {
@@ -21175,11 +21175,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_uchar_1 = 319;
+    private final static int mExportReduceIdx_my_char2_uchar_1 = 319;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_uchar_1(byte[] in1, byte[] in2) {
@@ -21243,11 +21243,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_uchar2_0 = 320;
+    private final static int mExportReduceIdx_my_char2_uchar2_0 = 320;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_uchar2_0(byte[] in1, byte[] in2) {
@@ -21315,11 +21315,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_uchar2_1 = 321;
+    private final static int mExportReduceIdx_my_char2_uchar2_1 = 321;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_uchar2_1(byte[] in1, byte[] in2) {
@@ -21387,11 +21387,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_uchar4_0 = 322;
+    private final static int mExportReduceIdx_my_char2_uchar4_0 = 322;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_uchar4_0(byte[] in1, byte[] in2) {
@@ -21459,11 +21459,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_uchar4_1 = 323;
+    private final static int mExportReduceIdx_my_char2_uchar4_1 = 323;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_uchar4_1(byte[] in1, byte[] in2) {
@@ -21531,11 +21531,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_ushort_0 = 324;
+    private final static int mExportReduceIdx_my_char2_ushort_0 = 324;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_ushort_0(byte[] in1, short[] in2) {
@@ -21599,11 +21599,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_ushort_1 = 325;
+    private final static int mExportReduceIdx_my_char2_ushort_1 = 325;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_ushort_1(byte[] in1, short[] in2) {
@@ -21667,11 +21667,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_ushort2_0 = 326;
+    private final static int mExportReduceIdx_my_char2_ushort2_0 = 326;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_ushort2_0(byte[] in1, short[] in2) {
@@ -21739,11 +21739,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_ushort2_1 = 327;
+    private final static int mExportReduceIdx_my_char2_ushort2_1 = 327;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char2_ushort2_1(byte[] in1, short[] in2) {
@@ -21811,11 +21811,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_ushort4_0 = 328;
+    private final static int mExportReduceIdx_my_char2_ushort4_0 = 328;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_ushort4_0(byte[] in1, short[] in2) {
@@ -21883,11 +21883,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_ushort4_1 = 329;
+    private final static int mExportReduceIdx_my_char2_ushort4_1 = 329;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char2_ushort4_1(byte[] in1, short[] in2) {
@@ -21955,11 +21955,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_bool_0 = 330;
+    private final static int mExportReduceIdx_my_char2_bool_0 = 330;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_bool_0(byte[] in1, byte[] in2) {
@@ -22023,11 +22023,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_bool_1 = 331;
+    private final static int mExportReduceIdx_my_char2_bool_1 = 331;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_char2_bool_1(byte[] in1, byte[] in2) {
@@ -22091,11 +22091,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_rs_matrix2x2_0 = 332;
+    private final static int mExportReduceIdx_my_char2_rs_matrix2x2_0 = 332;
     // ain1 = "char2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_char2_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -22125,11 +22125,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_rs_matrix2x2_1 = 333;
+    private final static int mExportReduceIdx_my_char2_rs_matrix2x2_1 = 333;
     // ain1 = "char2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_char2_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -22159,11 +22159,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_MyStruct_0 = 334;
+    private final static int mExportReduceIdx_my_char2_MyStruct_0 = 334;
     // ain1 = "char2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_char2_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -22196,11 +22196,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2_MyStruct_1 = 335;
+    private final static int mExportReduceIdx_my_char2_MyStruct_1 = 335;
     // ain1 = "char2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_char2_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -22233,11 +22233,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_half_0 = 336;
+    private final static int mExportReduceIdx_my_char4_half_0 = 336;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_half_0(byte[] in1, short[] in2) {
@@ -22301,11 +22301,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_half_1 = 337;
+    private final static int mExportReduceIdx_my_char4_half_1 = 337;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_half_1(byte[] in1, short[] in2) {
@@ -22369,11 +22369,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_half2_0 = 338;
+    private final static int mExportReduceIdx_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) {
@@ -22441,11 +22441,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_half2_1 = 339;
+    private final static int mExportReduceIdx_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) {
@@ -22513,11 +22513,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_half4_0 = 340;
+    private final static int mExportReduceIdx_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) {
@@ -22585,11 +22585,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_half4_1 = 341;
+    private final static int mExportReduceIdx_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) {
@@ -22657,11 +22657,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_float_0 = 342;
+    private final static int mExportReduceIdx_my_char4_float_0 = 342;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_float_0(byte[] in1, float[] in2) {
@@ -22725,11 +22725,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_float_1 = 343;
+    private final static int mExportReduceIdx_my_char4_float_1 = 343;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_float_1(byte[] in1, float[] in2) {
@@ -22793,11 +22793,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_float2_0 = 344;
+    private final static int mExportReduceIdx_my_char4_float2_0 = 344;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_float2_0(byte[] in1, float[] in2) {
@@ -22865,11 +22865,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_float2_1 = 345;
+    private final static int mExportReduceIdx_my_char4_float2_1 = 345;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_float2_1(byte[] in1, float[] in2) {
@@ -22937,11 +22937,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_float4_0 = 346;
+    private final static int mExportReduceIdx_my_char4_float4_0 = 346;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_float4_0(byte[] in1, float[] in2) {
@@ -23009,11 +23009,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_float4_1 = 347;
+    private final static int mExportReduceIdx_my_char4_float4_1 = 347;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_float4_1(byte[] in1, float[] in2) {
@@ -23081,11 +23081,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_char_0 = 348;
+    private final static int mExportReduceIdx_my_char4_char_0 = 348;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_char_0(byte[] in1, byte[] in2) {
@@ -23149,11 +23149,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_char_1 = 349;
+    private final static int mExportReduceIdx_my_char4_char_1 = 349;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_char_1(byte[] in1, byte[] in2) {
@@ -23217,11 +23217,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_char2_0 = 350;
+    private final static int mExportReduceIdx_my_char4_char2_0 = 350;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_char2_0(byte[] in1, byte[] in2) {
@@ -23289,11 +23289,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_char2_1 = 351;
+    private final static int mExportReduceIdx_my_char4_char2_1 = 351;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_char2_1(byte[] in1, byte[] in2) {
@@ -23361,11 +23361,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_char4_0 = 352;
+    private final static int mExportReduceIdx_my_char4_char4_0 = 352;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_char4_0(byte[] in1, byte[] in2) {
@@ -23433,11 +23433,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_char4_1 = 353;
+    private final static int mExportReduceIdx_my_char4_char4_1 = 353;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_char4_1(byte[] in1, byte[] in2) {
@@ -23505,11 +23505,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_short_0 = 354;
+    private final static int mExportReduceIdx_my_char4_short_0 = 354;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_short_0(byte[] in1, short[] in2) {
@@ -23573,11 +23573,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_short_1 = 355;
+    private final static int mExportReduceIdx_my_char4_short_1 = 355;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_short_1(byte[] in1, short[] in2) {
@@ -23641,11 +23641,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_short2_0 = 356;
+    private final static int mExportReduceIdx_my_char4_short2_0 = 356;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_short2_0(byte[] in1, short[] in2) {
@@ -23713,11 +23713,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_short2_1 = 357;
+    private final static int mExportReduceIdx_my_char4_short2_1 = 357;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_short2_1(byte[] in1, short[] in2) {
@@ -23785,11 +23785,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_short4_0 = 358;
+    private final static int mExportReduceIdx_my_char4_short4_0 = 358;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_short4_0(byte[] in1, short[] in2) {
@@ -23857,11 +23857,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_short4_1 = 359;
+    private final static int mExportReduceIdx_my_char4_short4_1 = 359;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_short4_1(byte[] in1, short[] in2) {
@@ -23929,11 +23929,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_uchar_0 = 360;
+    private final static int mExportReduceIdx_my_char4_uchar_0 = 360;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_uchar_0(byte[] in1, byte[] in2) {
@@ -23997,11 +23997,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_uchar_1 = 361;
+    private final static int mExportReduceIdx_my_char4_uchar_1 = 361;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_uchar_1(byte[] in1, byte[] in2) {
@@ -24065,11 +24065,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_uchar2_0 = 362;
+    private final static int mExportReduceIdx_my_char4_uchar2_0 = 362;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_uchar2_0(byte[] in1, byte[] in2) {
@@ -24137,11 +24137,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_uchar2_1 = 363;
+    private final static int mExportReduceIdx_my_char4_uchar2_1 = 363;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_uchar2_1(byte[] in1, byte[] in2) {
@@ -24209,11 +24209,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_uchar4_0 = 364;
+    private final static int mExportReduceIdx_my_char4_uchar4_0 = 364;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_uchar4_0(byte[] in1, byte[] in2) {
@@ -24281,11 +24281,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_uchar4_1 = 365;
+    private final static int mExportReduceIdx_my_char4_uchar4_1 = 365;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_uchar4_1(byte[] in1, byte[] in2) {
@@ -24353,11 +24353,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_ushort_0 = 366;
+    private final static int mExportReduceIdx_my_char4_ushort_0 = 366;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_ushort_0(byte[] in1, short[] in2) {
@@ -24421,11 +24421,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_ushort_1 = 367;
+    private final static int mExportReduceIdx_my_char4_ushort_1 = 367;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_ushort_1(byte[] in1, short[] in2) {
@@ -24489,11 +24489,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_ushort2_0 = 368;
+    private final static int mExportReduceIdx_my_char4_ushort2_0 = 368;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_ushort2_0(byte[] in1, short[] in2) {
@@ -24561,11 +24561,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_ushort2_1 = 369;
+    private final static int mExportReduceIdx_my_char4_ushort2_1 = 369;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_char4_ushort2_1(byte[] in1, short[] in2) {
@@ -24633,11 +24633,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_ushort4_0 = 370;
+    private final static int mExportReduceIdx_my_char4_ushort4_0 = 370;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_ushort4_0(byte[] in1, short[] in2) {
@@ -24705,11 +24705,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_ushort4_1 = 371;
+    private final static int mExportReduceIdx_my_char4_ushort4_1 = 371;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_char4_ushort4_1(byte[] in1, short[] in2) {
@@ -24777,11 +24777,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_bool_0 = 372;
+    private final static int mExportReduceIdx_my_char4_bool_0 = 372;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_bool_0(byte[] in1, byte[] in2) {
@@ -24845,11 +24845,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_bool_1 = 373;
+    private final static int mExportReduceIdx_my_char4_bool_1 = 373;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_char4_bool_1(byte[] in1, byte[] in2) {
@@ -24913,11 +24913,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_rs_matrix2x2_0 = 374;
+    private final static int mExportReduceIdx_my_char4_rs_matrix2x2_0 = 374;
     // ain1 = "char4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_char4_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -24947,11 +24947,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_rs_matrix2x2_1 = 375;
+    private final static int mExportReduceIdx_my_char4_rs_matrix2x2_1 = 375;
     // ain1 = "char4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_char4_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -24981,11 +24981,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_MyStruct_0 = 376;
+    private final static int mExportReduceIdx_my_char4_MyStruct_0 = 376;
     // ain1 = "char4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_char4_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -25018,11 +25018,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4_MyStruct_1 = 377;
+    private final static int mExportReduceIdx_my_char4_MyStruct_1 = 377;
     // ain1 = "char4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_char4_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -25055,11 +25055,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_char4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_half_0 = 378;
+    private final static int mExportReduceIdx_my_short_half_0 = 378;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_half_0(short[] in1, short[] in2) {
@@ -25119,11 +25119,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_half_1 = 379;
+    private final static int mExportReduceIdx_my_short_half_1 = 379;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_half_1(short[] in1, short[] in2) {
@@ -25183,11 +25183,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_half2_0 = 380;
+    private final static int mExportReduceIdx_my_short_half2_0 = 380;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_half2_0(short[] in1, short[] in2) {
@@ -25251,11 +25251,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_half2_1 = 381;
+    private final static int mExportReduceIdx_my_short_half2_1 = 381;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_half2_1(short[] in1, short[] in2) {
@@ -25319,11 +25319,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_half4_0 = 382;
+    private final static int mExportReduceIdx_my_short_half4_0 = 382;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_half4_0(short[] in1, short[] in2) {
@@ -25387,11 +25387,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_half4_1 = 383;
+    private final static int mExportReduceIdx_my_short_half4_1 = 383;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_half4_1(short[] in1, short[] in2) {
@@ -25455,11 +25455,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_float_0 = 384;
+    private final static int mExportReduceIdx_my_short_float_0 = 384;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_float_0(short[] in1, float[] in2) {
@@ -25519,11 +25519,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_float_1 = 385;
+    private final static int mExportReduceIdx_my_short_float_1 = 385;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_float_1(short[] in1, float[] in2) {
@@ -25583,11 +25583,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_float2_0 = 386;
+    private final static int mExportReduceIdx_my_short_float2_0 = 386;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_float2_0(short[] in1, float[] in2) {
@@ -25651,11 +25651,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_float2_1 = 387;
+    private final static int mExportReduceIdx_my_short_float2_1 = 387;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_float2_1(short[] in1, float[] in2) {
@@ -25719,11 +25719,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_float4_0 = 388;
+    private final static int mExportReduceIdx_my_short_float4_0 = 388;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_float4_0(short[] in1, float[] in2) {
@@ -25787,11 +25787,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_float4_1 = 389;
+    private final static int mExportReduceIdx_my_short_float4_1 = 389;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_float4_1(short[] in1, float[] in2) {
@@ -25855,11 +25855,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_char_0 = 390;
+    private final static int mExportReduceIdx_my_short_char_0 = 390;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_char_0(short[] in1, byte[] in2) {
@@ -25919,11 +25919,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_char_1 = 391;
+    private final static int mExportReduceIdx_my_short_char_1 = 391;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_char_1(short[] in1, byte[] in2) {
@@ -25983,11 +25983,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_char2_0 = 392;
+    private final static int mExportReduceIdx_my_short_char2_0 = 392;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_char2_0(short[] in1, byte[] in2) {
@@ -26051,11 +26051,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_char2_1 = 393;
+    private final static int mExportReduceIdx_my_short_char2_1 = 393;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_char2_1(short[] in1, byte[] in2) {
@@ -26119,11 +26119,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_char4_0 = 394;
+    private final static int mExportReduceIdx_my_short_char4_0 = 394;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_char4_0(short[] in1, byte[] in2) {
@@ -26187,11 +26187,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_char4_1 = 395;
+    private final static int mExportReduceIdx_my_short_char4_1 = 395;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_char4_1(short[] in1, byte[] in2) {
@@ -26255,11 +26255,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_short_0 = 396;
+    private final static int mExportReduceIdx_my_short_short_0 = 396;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_short_0(short[] in1, short[] in2) {
@@ -26319,11 +26319,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_short_1 = 397;
+    private final static int mExportReduceIdx_my_short_short_1 = 397;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_short_1(short[] in1, short[] in2) {
@@ -26383,11 +26383,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_short2_0 = 398;
+    private final static int mExportReduceIdx_my_short_short2_0 = 398;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_short2_0(short[] in1, short[] in2) {
@@ -26451,11 +26451,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_short2_1 = 399;
+    private final static int mExportReduceIdx_my_short_short2_1 = 399;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_short2_1(short[] in1, short[] in2) {
@@ -26519,11 +26519,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_short4_0 = 400;
+    private final static int mExportReduceIdx_my_short_short4_0 = 400;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_short4_0(short[] in1, short[] in2) {
@@ -26587,11 +26587,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_short4_1 = 401;
+    private final static int mExportReduceIdx_my_short_short4_1 = 401;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_short4_1(short[] in1, short[] in2) {
@@ -26655,11 +26655,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_uchar_0 = 402;
+    private final static int mExportReduceIdx_my_short_uchar_0 = 402;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_uchar_0(short[] in1, byte[] in2) {
@@ -26719,11 +26719,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_uchar_1 = 403;
+    private final static int mExportReduceIdx_my_short_uchar_1 = 403;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_uchar_1(short[] in1, byte[] in2) {
@@ -26783,11 +26783,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_uchar2_0 = 404;
+    private final static int mExportReduceIdx_my_short_uchar2_0 = 404;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_uchar2_0(short[] in1, byte[] in2) {
@@ -26851,11 +26851,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_uchar2_1 = 405;
+    private final static int mExportReduceIdx_my_short_uchar2_1 = 405;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_uchar2_1(short[] in1, byte[] in2) {
@@ -26919,11 +26919,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_uchar4_0 = 406;
+    private final static int mExportReduceIdx_my_short_uchar4_0 = 406;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_uchar4_0(short[] in1, byte[] in2) {
@@ -26987,11 +26987,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_uchar4_1 = 407;
+    private final static int mExportReduceIdx_my_short_uchar4_1 = 407;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_uchar4_1(short[] in1, byte[] in2) {
@@ -27055,11 +27055,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_ushort_0 = 408;
+    private final static int mExportReduceIdx_my_short_ushort_0 = 408;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_ushort_0(short[] in1, short[] in2) {
@@ -27119,11 +27119,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_ushort_1 = 409;
+    private final static int mExportReduceIdx_my_short_ushort_1 = 409;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_ushort_1(short[] in1, short[] in2) {
@@ -27183,11 +27183,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_ushort2_0 = 410;
+    private final static int mExportReduceIdx_my_short_ushort2_0 = 410;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_ushort2_0(short[] in1, short[] in2) {
@@ -27251,11 +27251,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_ushort2_1 = 411;
+    private final static int mExportReduceIdx_my_short_ushort2_1 = 411;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short_ushort2_1(short[] in1, short[] in2) {
@@ -27319,11 +27319,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_ushort4_0 = 412;
+    private final static int mExportReduceIdx_my_short_ushort4_0 = 412;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_ushort4_0(short[] in1, short[] in2) {
@@ -27387,11 +27387,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_ushort4_1 = 413;
+    private final static int mExportReduceIdx_my_short_ushort4_1 = 413;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short_ushort4_1(short[] in1, short[] in2) {
@@ -27455,11 +27455,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_bool_0 = 414;
+    private final static int mExportReduceIdx_my_short_bool_0 = 414;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_bool_0(short[] in1, byte[] in2) {
@@ -27519,11 +27519,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_bool_1 = 415;
+    private final static int mExportReduceIdx_my_short_bool_1 = 415;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_short_bool_1(short[] in1, byte[] in2) {
@@ -27583,11 +27583,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_rs_matrix2x2_0 = 416;
+    private final static int mExportReduceIdx_my_short_rs_matrix2x2_0 = 416;
     // ain1 = "short a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_short_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -27617,11 +27617,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_rs_matrix2x2_1 = 417;
+    private final static int mExportReduceIdx_my_short_rs_matrix2x2_1 = 417;
     // ain1 = "short a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_short_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -27651,11 +27651,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_MyStruct_0 = 418;
+    private final static int mExportReduceIdx_my_short_MyStruct_0 = 418;
     // ain1 = "short a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_short_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -27688,11 +27688,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short_MyStruct_1 = 419;
+    private final static int mExportReduceIdx_my_short_MyStruct_1 = 419;
     // ain1 = "short a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_short_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -27725,11 +27725,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_half_0 = 420;
+    private final static int mExportReduceIdx_my_short2_half_0 = 420;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_half_0(short[] in1, short[] in2) {
@@ -27793,11 +27793,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_half_1 = 421;
+    private final static int mExportReduceIdx_my_short2_half_1 = 421;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_half_1(short[] in1, short[] in2) {
@@ -27861,11 +27861,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_half2_0 = 422;
+    private final static int mExportReduceIdx_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) {
@@ -27933,11 +27933,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_half2_1 = 423;
+    private final static int mExportReduceIdx_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) {
@@ -28005,11 +28005,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_half4_0 = 424;
+    private final static int mExportReduceIdx_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) {
@@ -28077,11 +28077,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_half4_1 = 425;
+    private final static int mExportReduceIdx_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) {
@@ -28149,11 +28149,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_float_0 = 426;
+    private final static int mExportReduceIdx_my_short2_float_0 = 426;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_float_0(short[] in1, float[] in2) {
@@ -28217,11 +28217,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_float_1 = 427;
+    private final static int mExportReduceIdx_my_short2_float_1 = 427;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_float_1(short[] in1, float[] in2) {
@@ -28285,11 +28285,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_float2_0 = 428;
+    private final static int mExportReduceIdx_my_short2_float2_0 = 428;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_float2_0(short[] in1, float[] in2) {
@@ -28357,11 +28357,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_float2_1 = 429;
+    private final static int mExportReduceIdx_my_short2_float2_1 = 429;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_float2_1(short[] in1, float[] in2) {
@@ -28429,11 +28429,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_float4_0 = 430;
+    private final static int mExportReduceIdx_my_short2_float4_0 = 430;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_float4_0(short[] in1, float[] in2) {
@@ -28501,11 +28501,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_float4_1 = 431;
+    private final static int mExportReduceIdx_my_short2_float4_1 = 431;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_float4_1(short[] in1, float[] in2) {
@@ -28573,11 +28573,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_char_0 = 432;
+    private final static int mExportReduceIdx_my_short2_char_0 = 432;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_char_0(short[] in1, byte[] in2) {
@@ -28641,11 +28641,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_char_1 = 433;
+    private final static int mExportReduceIdx_my_short2_char_1 = 433;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_char_1(short[] in1, byte[] in2) {
@@ -28709,11 +28709,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_char2_0 = 434;
+    private final static int mExportReduceIdx_my_short2_char2_0 = 434;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_char2_0(short[] in1, byte[] in2) {
@@ -28781,11 +28781,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_char2_1 = 435;
+    private final static int mExportReduceIdx_my_short2_char2_1 = 435;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_char2_1(short[] in1, byte[] in2) {
@@ -28853,11 +28853,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_char4_0 = 436;
+    private final static int mExportReduceIdx_my_short2_char4_0 = 436;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_char4_0(short[] in1, byte[] in2) {
@@ -28925,11 +28925,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_char4_1 = 437;
+    private final static int mExportReduceIdx_my_short2_char4_1 = 437;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_char4_1(short[] in1, byte[] in2) {
@@ -28997,11 +28997,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_short_0 = 438;
+    private final static int mExportReduceIdx_my_short2_short_0 = 438;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_short_0(short[] in1, short[] in2) {
@@ -29065,11 +29065,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_short_1 = 439;
+    private final static int mExportReduceIdx_my_short2_short_1 = 439;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_short_1(short[] in1, short[] in2) {
@@ -29133,11 +29133,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_short2_0 = 440;
+    private final static int mExportReduceIdx_my_short2_short2_0 = 440;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_short2_0(short[] in1, short[] in2) {
@@ -29205,11 +29205,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_short2_1 = 441;
+    private final static int mExportReduceIdx_my_short2_short2_1 = 441;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_short2_1(short[] in1, short[] in2) {
@@ -29277,11 +29277,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_short4_0 = 442;
+    private final static int mExportReduceIdx_my_short2_short4_0 = 442;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_short4_0(short[] in1, short[] in2) {
@@ -29349,11 +29349,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_short4_1 = 443;
+    private final static int mExportReduceIdx_my_short2_short4_1 = 443;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_short4_1(short[] in1, short[] in2) {
@@ -29421,11 +29421,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_uchar_0 = 444;
+    private final static int mExportReduceIdx_my_short2_uchar_0 = 444;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_uchar_0(short[] in1, byte[] in2) {
@@ -29489,11 +29489,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_uchar_1 = 445;
+    private final static int mExportReduceIdx_my_short2_uchar_1 = 445;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_uchar_1(short[] in1, byte[] in2) {
@@ -29557,11 +29557,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_uchar2_0 = 446;
+    private final static int mExportReduceIdx_my_short2_uchar2_0 = 446;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_uchar2_0(short[] in1, byte[] in2) {
@@ -29629,11 +29629,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_uchar2_1 = 447;
+    private final static int mExportReduceIdx_my_short2_uchar2_1 = 447;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_uchar2_1(short[] in1, byte[] in2) {
@@ -29701,11 +29701,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_uchar4_0 = 448;
+    private final static int mExportReduceIdx_my_short2_uchar4_0 = 448;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_uchar4_0(short[] in1, byte[] in2) {
@@ -29773,11 +29773,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_uchar4_1 = 449;
+    private final static int mExportReduceIdx_my_short2_uchar4_1 = 449;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_uchar4_1(short[] in1, byte[] in2) {
@@ -29845,11 +29845,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_ushort_0 = 450;
+    private final static int mExportReduceIdx_my_short2_ushort_0 = 450;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_ushort_0(short[] in1, short[] in2) {
@@ -29913,11 +29913,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_ushort_1 = 451;
+    private final static int mExportReduceIdx_my_short2_ushort_1 = 451;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_ushort_1(short[] in1, short[] in2) {
@@ -29981,11 +29981,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_ushort2_0 = 452;
+    private final static int mExportReduceIdx_my_short2_ushort2_0 = 452;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_ushort2_0(short[] in1, short[] in2) {
@@ -30053,11 +30053,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_ushort2_1 = 453;
+    private final static int mExportReduceIdx_my_short2_ushort2_1 = 453;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short2_ushort2_1(short[] in1, short[] in2) {
@@ -30125,11 +30125,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_ushort4_0 = 454;
+    private final static int mExportReduceIdx_my_short2_ushort4_0 = 454;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_ushort4_0(short[] in1, short[] in2) {
@@ -30197,11 +30197,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_ushort4_1 = 455;
+    private final static int mExportReduceIdx_my_short2_ushort4_1 = 455;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short2_ushort4_1(short[] in1, short[] in2) {
@@ -30269,11 +30269,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_bool_0 = 456;
+    private final static int mExportReduceIdx_my_short2_bool_0 = 456;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_bool_0(short[] in1, byte[] in2) {
@@ -30337,11 +30337,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_bool_1 = 457;
+    private final static int mExportReduceIdx_my_short2_bool_1 = 457;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_short2_bool_1(short[] in1, byte[] in2) {
@@ -30405,11 +30405,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_rs_matrix2x2_0 = 458;
+    private final static int mExportReduceIdx_my_short2_rs_matrix2x2_0 = 458;
     // ain1 = "short2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_short2_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -30439,11 +30439,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_rs_matrix2x2_1 = 459;
+    private final static int mExportReduceIdx_my_short2_rs_matrix2x2_1 = 459;
     // ain1 = "short2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_short2_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -30473,11 +30473,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_MyStruct_0 = 460;
+    private final static int mExportReduceIdx_my_short2_MyStruct_0 = 460;
     // ain1 = "short2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_short2_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -30510,11 +30510,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2_MyStruct_1 = 461;
+    private final static int mExportReduceIdx_my_short2_MyStruct_1 = 461;
     // ain1 = "short2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_short2_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -30547,11 +30547,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_half_0 = 462;
+    private final static int mExportReduceIdx_my_short4_half_0 = 462;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_half_0(short[] in1, short[] in2) {
@@ -30615,11 +30615,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_half_1 = 463;
+    private final static int mExportReduceIdx_my_short4_half_1 = 463;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_half_1(short[] in1, short[] in2) {
@@ -30683,11 +30683,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_half2_0 = 464;
+    private final static int mExportReduceIdx_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) {
@@ -30755,11 +30755,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_half2_1 = 465;
+    private final static int mExportReduceIdx_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) {
@@ -30827,11 +30827,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_half4_0 = 466;
+    private final static int mExportReduceIdx_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) {
@@ -30899,11 +30899,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_half4_1 = 467;
+    private final static int mExportReduceIdx_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) {
@@ -30971,11 +30971,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_float_0 = 468;
+    private final static int mExportReduceIdx_my_short4_float_0 = 468;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_float_0(short[] in1, float[] in2) {
@@ -31039,11 +31039,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_float_1 = 469;
+    private final static int mExportReduceIdx_my_short4_float_1 = 469;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_float_1(short[] in1, float[] in2) {
@@ -31107,11 +31107,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_float2_0 = 470;
+    private final static int mExportReduceIdx_my_short4_float2_0 = 470;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_float2_0(short[] in1, float[] in2) {
@@ -31179,11 +31179,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_float2_1 = 471;
+    private final static int mExportReduceIdx_my_short4_float2_1 = 471;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_float2_1(short[] in1, float[] in2) {
@@ -31251,11 +31251,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_float4_0 = 472;
+    private final static int mExportReduceIdx_my_short4_float4_0 = 472;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_float4_0(short[] in1, float[] in2) {
@@ -31323,11 +31323,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_float4_1 = 473;
+    private final static int mExportReduceIdx_my_short4_float4_1 = 473;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_float4_1(short[] in1, float[] in2) {
@@ -31395,11 +31395,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_char_0 = 474;
+    private final static int mExportReduceIdx_my_short4_char_0 = 474;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_char_0(short[] in1, byte[] in2) {
@@ -31463,11 +31463,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_char_1 = 475;
+    private final static int mExportReduceIdx_my_short4_char_1 = 475;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_char_1(short[] in1, byte[] in2) {
@@ -31531,11 +31531,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_char2_0 = 476;
+    private final static int mExportReduceIdx_my_short4_char2_0 = 476;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_char2_0(short[] in1, byte[] in2) {
@@ -31603,11 +31603,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_char2_1 = 477;
+    private final static int mExportReduceIdx_my_short4_char2_1 = 477;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_char2_1(short[] in1, byte[] in2) {
@@ -31675,11 +31675,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_char4_0 = 478;
+    private final static int mExportReduceIdx_my_short4_char4_0 = 478;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_char4_0(short[] in1, byte[] in2) {
@@ -31747,11 +31747,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_char4_1 = 479;
+    private final static int mExportReduceIdx_my_short4_char4_1 = 479;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_char4_1(short[] in1, byte[] in2) {
@@ -31819,11 +31819,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_short_0 = 480;
+    private final static int mExportReduceIdx_my_short4_short_0 = 480;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_short_0(short[] in1, short[] in2) {
@@ -31887,11 +31887,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_short_1 = 481;
+    private final static int mExportReduceIdx_my_short4_short_1 = 481;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_short_1(short[] in1, short[] in2) {
@@ -31955,11 +31955,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_short2_0 = 482;
+    private final static int mExportReduceIdx_my_short4_short2_0 = 482;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_short2_0(short[] in1, short[] in2) {
@@ -32027,11 +32027,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_short2_1 = 483;
+    private final static int mExportReduceIdx_my_short4_short2_1 = 483;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_short2_1(short[] in1, short[] in2) {
@@ -32099,11 +32099,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_short4_0 = 484;
+    private final static int mExportReduceIdx_my_short4_short4_0 = 484;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_short4_0(short[] in1, short[] in2) {
@@ -32171,11 +32171,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_short4_1 = 485;
+    private final static int mExportReduceIdx_my_short4_short4_1 = 485;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_short4_1(short[] in1, short[] in2) {
@@ -32243,11 +32243,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_uchar_0 = 486;
+    private final static int mExportReduceIdx_my_short4_uchar_0 = 486;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_uchar_0(short[] in1, byte[] in2) {
@@ -32311,11 +32311,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_uchar_1 = 487;
+    private final static int mExportReduceIdx_my_short4_uchar_1 = 487;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_uchar_1(short[] in1, byte[] in2) {
@@ -32379,11 +32379,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_uchar2_0 = 488;
+    private final static int mExportReduceIdx_my_short4_uchar2_0 = 488;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_uchar2_0(short[] in1, byte[] in2) {
@@ -32451,11 +32451,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_uchar2_1 = 489;
+    private final static int mExportReduceIdx_my_short4_uchar2_1 = 489;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_uchar2_1(short[] in1, byte[] in2) {
@@ -32523,11 +32523,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_uchar4_0 = 490;
+    private final static int mExportReduceIdx_my_short4_uchar4_0 = 490;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_uchar4_0(short[] in1, byte[] in2) {
@@ -32595,11 +32595,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_uchar4_1 = 491;
+    private final static int mExportReduceIdx_my_short4_uchar4_1 = 491;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_uchar4_1(short[] in1, byte[] in2) {
@@ -32667,11 +32667,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_ushort_0 = 492;
+    private final static int mExportReduceIdx_my_short4_ushort_0 = 492;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_ushort_0(short[] in1, short[] in2) {
@@ -32735,11 +32735,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_ushort_1 = 493;
+    private final static int mExportReduceIdx_my_short4_ushort_1 = 493;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_ushort_1(short[] in1, short[] in2) {
@@ -32803,11 +32803,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_ushort2_0 = 494;
+    private final static int mExportReduceIdx_my_short4_ushort2_0 = 494;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_ushort2_0(short[] in1, short[] in2) {
@@ -32875,11 +32875,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_ushort2_1 = 495;
+    private final static int mExportReduceIdx_my_short4_ushort2_1 = 495;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_short4_ushort2_1(short[] in1, short[] in2) {
@@ -32947,11 +32947,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_ushort4_0 = 496;
+    private final static int mExportReduceIdx_my_short4_ushort4_0 = 496;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_ushort4_0(short[] in1, short[] in2) {
@@ -33019,11 +33019,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_ushort4_1 = 497;
+    private final static int mExportReduceIdx_my_short4_ushort4_1 = 497;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_short4_ushort4_1(short[] in1, short[] in2) {
@@ -33091,11 +33091,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_bool_0 = 498;
+    private final static int mExportReduceIdx_my_short4_bool_0 = 498;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_bool_0(short[] in1, byte[] in2) {
@@ -33159,11 +33159,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_bool_1 = 499;
+    private final static int mExportReduceIdx_my_short4_bool_1 = 499;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_short4_bool_1(short[] in1, byte[] in2) {
@@ -33227,11 +33227,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_rs_matrix2x2_0 = 500;
+    private final static int mExportReduceIdx_my_short4_rs_matrix2x2_0 = 500;
     // ain1 = "short4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_short4_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -33261,11 +33261,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_rs_matrix2x2_1 = 501;
+    private final static int mExportReduceIdx_my_short4_rs_matrix2x2_1 = 501;
     // ain1 = "short4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_short4_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -33295,11 +33295,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_MyStruct_0 = 502;
+    private final static int mExportReduceIdx_my_short4_MyStruct_0 = 502;
     // ain1 = "short4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_short4_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -33332,11 +33332,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4_MyStruct_1 = 503;
+    private final static int mExportReduceIdx_my_short4_MyStruct_1 = 503;
     // ain1 = "short4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_short4_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -33369,11 +33369,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_short4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_half_0 = 504;
+    private final static int mExportReduceIdx_my_uchar_half_0 = 504;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_half_0(byte[] in1, short[] in2) {
@@ -33433,11 +33433,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_half_1 = 505;
+    private final static int mExportReduceIdx_my_uchar_half_1 = 505;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_half_1(byte[] in1, short[] in2) {
@@ -33497,11 +33497,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_half2_0 = 506;
+    private final static int mExportReduceIdx_my_uchar_half2_0 = 506;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_half2_0(byte[] in1, short[] in2) {
@@ -33565,11 +33565,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_half2_1 = 507;
+    private final static int mExportReduceIdx_my_uchar_half2_1 = 507;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_half2_1(byte[] in1, short[] in2) {
@@ -33633,11 +33633,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_half4_0 = 508;
+    private final static int mExportReduceIdx_my_uchar_half4_0 = 508;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_half4_0(byte[] in1, short[] in2) {
@@ -33701,11 +33701,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_half4_1 = 509;
+    private final static int mExportReduceIdx_my_uchar_half4_1 = 509;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_half4_1(byte[] in1, short[] in2) {
@@ -33769,11 +33769,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_float_0 = 510;
+    private final static int mExportReduceIdx_my_uchar_float_0 = 510;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_float_0(byte[] in1, float[] in2) {
@@ -33833,11 +33833,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_float_1 = 511;
+    private final static int mExportReduceIdx_my_uchar_float_1 = 511;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_float_1(byte[] in1, float[] in2) {
@@ -33897,11 +33897,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_float2_0 = 512;
+    private final static int mExportReduceIdx_my_uchar_float2_0 = 512;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_float2_0(byte[] in1, float[] in2) {
@@ -33965,11 +33965,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_float2_1 = 513;
+    private final static int mExportReduceIdx_my_uchar_float2_1 = 513;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_float2_1(byte[] in1, float[] in2) {
@@ -34033,11 +34033,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_float4_0 = 514;
+    private final static int mExportReduceIdx_my_uchar_float4_0 = 514;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_float4_0(byte[] in1, float[] in2) {
@@ -34101,11 +34101,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_float4_1 = 515;
+    private final static int mExportReduceIdx_my_uchar_float4_1 = 515;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_float4_1(byte[] in1, float[] in2) {
@@ -34169,11 +34169,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_char_0 = 516;
+    private final static int mExportReduceIdx_my_uchar_char_0 = 516;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_char_0(byte[] in1, byte[] in2) {
@@ -34233,11 +34233,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_char_1 = 517;
+    private final static int mExportReduceIdx_my_uchar_char_1 = 517;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_char_1(byte[] in1, byte[] in2) {
@@ -34297,11 +34297,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_char2_0 = 518;
+    private final static int mExportReduceIdx_my_uchar_char2_0 = 518;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_char2_0(byte[] in1, byte[] in2) {
@@ -34365,11 +34365,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_char2_1 = 519;
+    private final static int mExportReduceIdx_my_uchar_char2_1 = 519;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_char2_1(byte[] in1, byte[] in2) {
@@ -34433,11 +34433,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_char4_0 = 520;
+    private final static int mExportReduceIdx_my_uchar_char4_0 = 520;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_char4_0(byte[] in1, byte[] in2) {
@@ -34501,11 +34501,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_char4_1 = 521;
+    private final static int mExportReduceIdx_my_uchar_char4_1 = 521;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_char4_1(byte[] in1, byte[] in2) {
@@ -34569,11 +34569,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_short_0 = 522;
+    private final static int mExportReduceIdx_my_uchar_short_0 = 522;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_short_0(byte[] in1, short[] in2) {
@@ -34633,11 +34633,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_short_1 = 523;
+    private final static int mExportReduceIdx_my_uchar_short_1 = 523;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_short_1(byte[] in1, short[] in2) {
@@ -34697,11 +34697,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_short2_0 = 524;
+    private final static int mExportReduceIdx_my_uchar_short2_0 = 524;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_short2_0(byte[] in1, short[] in2) {
@@ -34765,11 +34765,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_short2_1 = 525;
+    private final static int mExportReduceIdx_my_uchar_short2_1 = 525;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_short2_1(byte[] in1, short[] in2) {
@@ -34833,11 +34833,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_short4_0 = 526;
+    private final static int mExportReduceIdx_my_uchar_short4_0 = 526;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_short4_0(byte[] in1, short[] in2) {
@@ -34901,11 +34901,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_short4_1 = 527;
+    private final static int mExportReduceIdx_my_uchar_short4_1 = 527;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_short4_1(byte[] in1, short[] in2) {
@@ -34969,11 +34969,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_uchar_0 = 528;
+    private final static int mExportReduceIdx_my_uchar_uchar_0 = 528;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_uchar_0(byte[] in1, byte[] in2) {
@@ -35033,11 +35033,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_uchar_1 = 529;
+    private final static int mExportReduceIdx_my_uchar_uchar_1 = 529;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_uchar_1(byte[] in1, byte[] in2) {
@@ -35097,11 +35097,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_uchar2_0 = 530;
+    private final static int mExportReduceIdx_my_uchar_uchar2_0 = 530;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_uchar2_0(byte[] in1, byte[] in2) {
@@ -35165,11 +35165,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_uchar2_1 = 531;
+    private final static int mExportReduceIdx_my_uchar_uchar2_1 = 531;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_uchar2_1(byte[] in1, byte[] in2) {
@@ -35233,11 +35233,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_uchar4_0 = 532;
+    private final static int mExportReduceIdx_my_uchar_uchar4_0 = 532;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_uchar4_0(byte[] in1, byte[] in2) {
@@ -35301,11 +35301,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_uchar4_1 = 533;
+    private final static int mExportReduceIdx_my_uchar_uchar4_1 = 533;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_uchar4_1(byte[] in1, byte[] in2) {
@@ -35369,11 +35369,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_ushort_0 = 534;
+    private final static int mExportReduceIdx_my_uchar_ushort_0 = 534;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_ushort_0(byte[] in1, short[] in2) {
@@ -35433,11 +35433,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_ushort_1 = 535;
+    private final static int mExportReduceIdx_my_uchar_ushort_1 = 535;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_ushort_1(byte[] in1, short[] in2) {
@@ -35497,11 +35497,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_ushort2_0 = 536;
+    private final static int mExportReduceIdx_my_uchar_ushort2_0 = 536;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_ushort2_0(byte[] in1, short[] in2) {
@@ -35565,11 +35565,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_ushort2_1 = 537;
+    private final static int mExportReduceIdx_my_uchar_ushort2_1 = 537;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar_ushort2_1(byte[] in1, short[] in2) {
@@ -35633,11 +35633,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_ushort4_0 = 538;
+    private final static int mExportReduceIdx_my_uchar_ushort4_0 = 538;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_ushort4_0(byte[] in1, short[] in2) {
@@ -35701,11 +35701,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_ushort4_1 = 539;
+    private final static int mExportReduceIdx_my_uchar_ushort4_1 = 539;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar_ushort4_1(byte[] in1, short[] in2) {
@@ -35769,11 +35769,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_bool_0 = 540;
+    private final static int mExportReduceIdx_my_uchar_bool_0 = 540;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_bool_0(byte[] in1, byte[] in2) {
@@ -35833,11 +35833,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_bool_1 = 541;
+    private final static int mExportReduceIdx_my_uchar_bool_1 = 541;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_uchar_bool_1(byte[] in1, byte[] in2) {
@@ -35897,11 +35897,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_rs_matrix2x2_0 = 542;
+    private final static int mExportReduceIdx_my_uchar_rs_matrix2x2_0 = 542;
     // ain1 = "uchar a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_uchar_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -35931,11 +35931,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_rs_matrix2x2_1 = 543;
+    private final static int mExportReduceIdx_my_uchar_rs_matrix2x2_1 = 543;
     // ain1 = "uchar a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_uchar_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -35965,11 +35965,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_MyStruct_0 = 544;
+    private final static int mExportReduceIdx_my_uchar_MyStruct_0 = 544;
     // ain1 = "uchar a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_uchar_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -36002,11 +36002,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar_MyStruct_1 = 545;
+    private final static int mExportReduceIdx_my_uchar_MyStruct_1 = 545;
     // ain1 = "uchar a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_uchar_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -36039,11 +36039,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_half_0 = 546;
+    private final static int mExportReduceIdx_my_uchar2_half_0 = 546;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_half_0(byte[] in1, short[] in2) {
@@ -36107,11 +36107,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_half_1 = 547;
+    private final static int mExportReduceIdx_my_uchar2_half_1 = 547;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_half_1(byte[] in1, short[] in2) {
@@ -36175,11 +36175,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_half2_0 = 548;
+    private final static int mExportReduceIdx_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) {
@@ -36247,11 +36247,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_half2_1 = 549;
+    private final static int mExportReduceIdx_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) {
@@ -36319,11 +36319,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_half4_0 = 550;
+    private final static int mExportReduceIdx_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) {
@@ -36391,11 +36391,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_half4_1 = 551;
+    private final static int mExportReduceIdx_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) {
@@ -36463,11 +36463,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_float_0 = 552;
+    private final static int mExportReduceIdx_my_uchar2_float_0 = 552;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_float_0(byte[] in1, float[] in2) {
@@ -36531,11 +36531,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_float_1 = 553;
+    private final static int mExportReduceIdx_my_uchar2_float_1 = 553;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_float_1(byte[] in1, float[] in2) {
@@ -36599,11 +36599,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_float2_0 = 554;
+    private final static int mExportReduceIdx_my_uchar2_float2_0 = 554;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_float2_0(byte[] in1, float[] in2) {
@@ -36671,11 +36671,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_float2_1 = 555;
+    private final static int mExportReduceIdx_my_uchar2_float2_1 = 555;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_float2_1(byte[] in1, float[] in2) {
@@ -36743,11 +36743,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_float4_0 = 556;
+    private final static int mExportReduceIdx_my_uchar2_float4_0 = 556;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_float4_0(byte[] in1, float[] in2) {
@@ -36815,11 +36815,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_float4_1 = 557;
+    private final static int mExportReduceIdx_my_uchar2_float4_1 = 557;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_float4_1(byte[] in1, float[] in2) {
@@ -36887,11 +36887,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_char_0 = 558;
+    private final static int mExportReduceIdx_my_uchar2_char_0 = 558;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_char_0(byte[] in1, byte[] in2) {
@@ -36955,11 +36955,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_char_1 = 559;
+    private final static int mExportReduceIdx_my_uchar2_char_1 = 559;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_char_1(byte[] in1, byte[] in2) {
@@ -37023,11 +37023,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_char2_0 = 560;
+    private final static int mExportReduceIdx_my_uchar2_char2_0 = 560;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_char2_0(byte[] in1, byte[] in2) {
@@ -37095,11 +37095,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_char2_1 = 561;
+    private final static int mExportReduceIdx_my_uchar2_char2_1 = 561;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_char2_1(byte[] in1, byte[] in2) {
@@ -37167,11 +37167,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_char4_0 = 562;
+    private final static int mExportReduceIdx_my_uchar2_char4_0 = 562;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_char4_0(byte[] in1, byte[] in2) {
@@ -37239,11 +37239,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_char4_1 = 563;
+    private final static int mExportReduceIdx_my_uchar2_char4_1 = 563;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_char4_1(byte[] in1, byte[] in2) {
@@ -37311,11 +37311,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_short_0 = 564;
+    private final static int mExportReduceIdx_my_uchar2_short_0 = 564;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_short_0(byte[] in1, short[] in2) {
@@ -37379,11 +37379,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_short_1 = 565;
+    private final static int mExportReduceIdx_my_uchar2_short_1 = 565;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_short_1(byte[] in1, short[] in2) {
@@ -37447,11 +37447,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_short2_0 = 566;
+    private final static int mExportReduceIdx_my_uchar2_short2_0 = 566;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_short2_0(byte[] in1, short[] in2) {
@@ -37519,11 +37519,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_short2_1 = 567;
+    private final static int mExportReduceIdx_my_uchar2_short2_1 = 567;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_short2_1(byte[] in1, short[] in2) {
@@ -37591,11 +37591,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_short4_0 = 568;
+    private final static int mExportReduceIdx_my_uchar2_short4_0 = 568;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_short4_0(byte[] in1, short[] in2) {
@@ -37663,11 +37663,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_short4_1 = 569;
+    private final static int mExportReduceIdx_my_uchar2_short4_1 = 569;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_short4_1(byte[] in1, short[] in2) {
@@ -37735,11 +37735,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_uchar_0 = 570;
+    private final static int mExportReduceIdx_my_uchar2_uchar_0 = 570;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_uchar_0(byte[] in1, byte[] in2) {
@@ -37803,11 +37803,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_uchar_1 = 571;
+    private final static int mExportReduceIdx_my_uchar2_uchar_1 = 571;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_uchar_1(byte[] in1, byte[] in2) {
@@ -37871,11 +37871,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_uchar2_0 = 572;
+    private final static int mExportReduceIdx_my_uchar2_uchar2_0 = 572;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_uchar2_0(byte[] in1, byte[] in2) {
@@ -37943,11 +37943,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_uchar2_1 = 573;
+    private final static int mExportReduceIdx_my_uchar2_uchar2_1 = 573;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_uchar2_1(byte[] in1, byte[] in2) {
@@ -38015,11 +38015,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_uchar4_0 = 574;
+    private final static int mExportReduceIdx_my_uchar2_uchar4_0 = 574;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_uchar4_0(byte[] in1, byte[] in2) {
@@ -38087,11 +38087,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_uchar4_1 = 575;
+    private final static int mExportReduceIdx_my_uchar2_uchar4_1 = 575;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_uchar4_1(byte[] in1, byte[] in2) {
@@ -38159,11 +38159,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_ushort_0 = 576;
+    private final static int mExportReduceIdx_my_uchar2_ushort_0 = 576;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_ushort_0(byte[] in1, short[] in2) {
@@ -38227,11 +38227,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_ushort_1 = 577;
+    private final static int mExportReduceIdx_my_uchar2_ushort_1 = 577;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_ushort_1(byte[] in1, short[] in2) {
@@ -38295,11 +38295,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_ushort2_0 = 578;
+    private final static int mExportReduceIdx_my_uchar2_ushort2_0 = 578;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_ushort2_0(byte[] in1, short[] in2) {
@@ -38367,11 +38367,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_ushort2_1 = 579;
+    private final static int mExportReduceIdx_my_uchar2_ushort2_1 = 579;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar2_ushort2_1(byte[] in1, short[] in2) {
@@ -38439,11 +38439,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_ushort4_0 = 580;
+    private final static int mExportReduceIdx_my_uchar2_ushort4_0 = 580;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_ushort4_0(byte[] in1, short[] in2) {
@@ -38511,11 +38511,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_ushort4_1 = 581;
+    private final static int mExportReduceIdx_my_uchar2_ushort4_1 = 581;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar2_ushort4_1(byte[] in1, short[] in2) {
@@ -38583,11 +38583,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_bool_0 = 582;
+    private final static int mExportReduceIdx_my_uchar2_bool_0 = 582;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_bool_0(byte[] in1, byte[] in2) {
@@ -38651,11 +38651,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_bool_1 = 583;
+    private final static int mExportReduceIdx_my_uchar2_bool_1 = 583;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_uchar2_bool_1(byte[] in1, byte[] in2) {
@@ -38719,11 +38719,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_rs_matrix2x2_0 = 584;
+    private final static int mExportReduceIdx_my_uchar2_rs_matrix2x2_0 = 584;
     // ain1 = "uchar2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_uchar2_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -38753,11 +38753,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_rs_matrix2x2_1 = 585;
+    private final static int mExportReduceIdx_my_uchar2_rs_matrix2x2_1 = 585;
     // ain1 = "uchar2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_uchar2_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -38787,11 +38787,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_MyStruct_0 = 586;
+    private final static int mExportReduceIdx_my_uchar2_MyStruct_0 = 586;
     // ain1 = "uchar2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_uchar2_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -38824,11 +38824,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2_MyStruct_1 = 587;
+    private final static int mExportReduceIdx_my_uchar2_MyStruct_1 = 587;
     // ain1 = "uchar2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_uchar2_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -38861,11 +38861,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_half_0 = 588;
+    private final static int mExportReduceIdx_my_uchar4_half_0 = 588;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_half_0(byte[] in1, short[] in2) {
@@ -38929,11 +38929,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_half_1 = 589;
+    private final static int mExportReduceIdx_my_uchar4_half_1 = 589;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_half_1(byte[] in1, short[] in2) {
@@ -38997,11 +38997,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_half2_0 = 590;
+    private final static int mExportReduceIdx_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) {
@@ -39069,11 +39069,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_half2_1 = 591;
+    private final static int mExportReduceIdx_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) {
@@ -39141,11 +39141,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_half4_0 = 592;
+    private final static int mExportReduceIdx_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) {
@@ -39213,11 +39213,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_half4_1 = 593;
+    private final static int mExportReduceIdx_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) {
@@ -39285,11 +39285,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_float_0 = 594;
+    private final static int mExportReduceIdx_my_uchar4_float_0 = 594;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_float_0(byte[] in1, float[] in2) {
@@ -39353,11 +39353,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_float_1 = 595;
+    private final static int mExportReduceIdx_my_uchar4_float_1 = 595;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_float_1(byte[] in1, float[] in2) {
@@ -39421,11 +39421,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_float2_0 = 596;
+    private final static int mExportReduceIdx_my_uchar4_float2_0 = 596;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_float2_0(byte[] in1, float[] in2) {
@@ -39493,11 +39493,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_float2_1 = 597;
+    private final static int mExportReduceIdx_my_uchar4_float2_1 = 597;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_float2_1(byte[] in1, float[] in2) {
@@ -39565,11 +39565,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_float4_0 = 598;
+    private final static int mExportReduceIdx_my_uchar4_float4_0 = 598;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_float4_0(byte[] in1, float[] in2) {
@@ -39637,11 +39637,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_float4_1 = 599;
+    private final static int mExportReduceIdx_my_uchar4_float4_1 = 599;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_float4_1(byte[] in1, float[] in2) {
@@ -39709,11 +39709,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_char_0 = 600;
+    private final static int mExportReduceIdx_my_uchar4_char_0 = 600;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_char_0(byte[] in1, byte[] in2) {
@@ -39777,11 +39777,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_char_1 = 601;
+    private final static int mExportReduceIdx_my_uchar4_char_1 = 601;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_char_1(byte[] in1, byte[] in2) {
@@ -39845,11 +39845,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_char2_0 = 602;
+    private final static int mExportReduceIdx_my_uchar4_char2_0 = 602;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_char2_0(byte[] in1, byte[] in2) {
@@ -39917,11 +39917,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_char2_1 = 603;
+    private final static int mExportReduceIdx_my_uchar4_char2_1 = 603;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_char2_1(byte[] in1, byte[] in2) {
@@ -39989,11 +39989,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_char4_0 = 604;
+    private final static int mExportReduceIdx_my_uchar4_char4_0 = 604;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_char4_0(byte[] in1, byte[] in2) {
@@ -40061,11 +40061,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_char4_1 = 605;
+    private final static int mExportReduceIdx_my_uchar4_char4_1 = 605;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_char4_1(byte[] in1, byte[] in2) {
@@ -40133,11 +40133,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_short_0 = 606;
+    private final static int mExportReduceIdx_my_uchar4_short_0 = 606;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_short_0(byte[] in1, short[] in2) {
@@ -40201,11 +40201,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_short_1 = 607;
+    private final static int mExportReduceIdx_my_uchar4_short_1 = 607;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_short_1(byte[] in1, short[] in2) {
@@ -40269,11 +40269,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_short2_0 = 608;
+    private final static int mExportReduceIdx_my_uchar4_short2_0 = 608;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_short2_0(byte[] in1, short[] in2) {
@@ -40341,11 +40341,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_short2_1 = 609;
+    private final static int mExportReduceIdx_my_uchar4_short2_1 = 609;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_short2_1(byte[] in1, short[] in2) {
@@ -40413,11 +40413,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_short4_0 = 610;
+    private final static int mExportReduceIdx_my_uchar4_short4_0 = 610;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_short4_0(byte[] in1, short[] in2) {
@@ -40485,11 +40485,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_short4_1 = 611;
+    private final static int mExportReduceIdx_my_uchar4_short4_1 = 611;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_short4_1(byte[] in1, short[] in2) {
@@ -40557,11 +40557,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_uchar_0 = 612;
+    private final static int mExportReduceIdx_my_uchar4_uchar_0 = 612;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_uchar_0(byte[] in1, byte[] in2) {
@@ -40625,11 +40625,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_uchar_1 = 613;
+    private final static int mExportReduceIdx_my_uchar4_uchar_1 = 613;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_uchar_1(byte[] in1, byte[] in2) {
@@ -40693,11 +40693,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_uchar2_0 = 614;
+    private final static int mExportReduceIdx_my_uchar4_uchar2_0 = 614;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_uchar2_0(byte[] in1, byte[] in2) {
@@ -40765,11 +40765,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_uchar2_1 = 615;
+    private final static int mExportReduceIdx_my_uchar4_uchar2_1 = 615;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_uchar2_1(byte[] in1, byte[] in2) {
@@ -40837,11 +40837,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_uchar4_0 = 616;
+    private final static int mExportReduceIdx_my_uchar4_uchar4_0 = 616;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_uchar4_0(byte[] in1, byte[] in2) {
@@ -40909,11 +40909,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_uchar4_1 = 617;
+    private final static int mExportReduceIdx_my_uchar4_uchar4_1 = 617;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_uchar4_1(byte[] in1, byte[] in2) {
@@ -40981,11 +40981,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_ushort_0 = 618;
+    private final static int mExportReduceIdx_my_uchar4_ushort_0 = 618;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_ushort_0(byte[] in1, short[] in2) {
@@ -41049,11 +41049,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_ushort_1 = 619;
+    private final static int mExportReduceIdx_my_uchar4_ushort_1 = 619;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_ushort_1(byte[] in1, short[] in2) {
@@ -41117,11 +41117,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_ushort2_0 = 620;
+    private final static int mExportReduceIdx_my_uchar4_ushort2_0 = 620;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_ushort2_0(byte[] in1, short[] in2) {
@@ -41189,11 +41189,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_ushort2_1 = 621;
+    private final static int mExportReduceIdx_my_uchar4_ushort2_1 = 621;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_uchar4_ushort2_1(byte[] in1, short[] in2) {
@@ -41261,11 +41261,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_ushort4_0 = 622;
+    private final static int mExportReduceIdx_my_uchar4_ushort4_0 = 622;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_ushort4_0(byte[] in1, short[] in2) {
@@ -41333,11 +41333,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_ushort4_1 = 623;
+    private final static int mExportReduceIdx_my_uchar4_ushort4_1 = 623;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_uchar4_ushort4_1(byte[] in1, short[] in2) {
@@ -41405,11 +41405,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_bool_0 = 624;
+    private final static int mExportReduceIdx_my_uchar4_bool_0 = 624;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_bool_0(byte[] in1, byte[] in2) {
@@ -41473,11 +41473,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_bool_1 = 625;
+    private final static int mExportReduceIdx_my_uchar4_bool_1 = 625;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_uchar4_bool_1(byte[] in1, byte[] in2) {
@@ -41541,11 +41541,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_rs_matrix2x2_0 = 626;
+    private final static int mExportReduceIdx_my_uchar4_rs_matrix2x2_0 = 626;
     // ain1 = "uchar4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_uchar4_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -41575,11 +41575,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_rs_matrix2x2_1 = 627;
+    private final static int mExportReduceIdx_my_uchar4_rs_matrix2x2_1 = 627;
     // ain1 = "uchar4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_uchar4_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -41609,11 +41609,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_MyStruct_0 = 628;
+    private final static int mExportReduceIdx_my_uchar4_MyStruct_0 = 628;
     // ain1 = "uchar4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_uchar4_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -41646,11 +41646,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4_MyStruct_1 = 629;
+    private final static int mExportReduceIdx_my_uchar4_MyStruct_1 = 629;
     // ain1 = "uchar4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_uchar4_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -41683,11 +41683,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_half_0 = 630;
+    private final static int mExportReduceIdx_my_ushort_half_0 = 630;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_half_0(short[] in1, short[] in2) {
@@ -41747,11 +41747,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_half_1 = 631;
+    private final static int mExportReduceIdx_my_ushort_half_1 = 631;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_half_1(short[] in1, short[] in2) {
@@ -41811,11 +41811,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_half2_0 = 632;
+    private final static int mExportReduceIdx_my_ushort_half2_0 = 632;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_half2_0(short[] in1, short[] in2) {
@@ -41879,11 +41879,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_half2_1 = 633;
+    private final static int mExportReduceIdx_my_ushort_half2_1 = 633;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_half2_1(short[] in1, short[] in2) {
@@ -41947,11 +41947,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_half4_0 = 634;
+    private final static int mExportReduceIdx_my_ushort_half4_0 = 634;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_half4_0(short[] in1, short[] in2) {
@@ -42015,11 +42015,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_half4_1 = 635;
+    private final static int mExportReduceIdx_my_ushort_half4_1 = 635;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_half4_1(short[] in1, short[] in2) {
@@ -42083,11 +42083,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_float_0 = 636;
+    private final static int mExportReduceIdx_my_ushort_float_0 = 636;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_float_0(short[] in1, float[] in2) {
@@ -42147,11 +42147,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_float_1 = 637;
+    private final static int mExportReduceIdx_my_ushort_float_1 = 637;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_float_1(short[] in1, float[] in2) {
@@ -42211,11 +42211,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_float2_0 = 638;
+    private final static int mExportReduceIdx_my_ushort_float2_0 = 638;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_float2_0(short[] in1, float[] in2) {
@@ -42279,11 +42279,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_float2_1 = 639;
+    private final static int mExportReduceIdx_my_ushort_float2_1 = 639;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_float2_1(short[] in1, float[] in2) {
@@ -42347,11 +42347,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_float4_0 = 640;
+    private final static int mExportReduceIdx_my_ushort_float4_0 = 640;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_float4_0(short[] in1, float[] in2) {
@@ -42415,11 +42415,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_float4_1 = 641;
+    private final static int mExportReduceIdx_my_ushort_float4_1 = 641;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_float4_1(short[] in1, float[] in2) {
@@ -42483,11 +42483,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_char_0 = 642;
+    private final static int mExportReduceIdx_my_ushort_char_0 = 642;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_char_0(short[] in1, byte[] in2) {
@@ -42547,11 +42547,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_char_1 = 643;
+    private final static int mExportReduceIdx_my_ushort_char_1 = 643;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_char_1(short[] in1, byte[] in2) {
@@ -42611,11 +42611,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_char2_0 = 644;
+    private final static int mExportReduceIdx_my_ushort_char2_0 = 644;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_char2_0(short[] in1, byte[] in2) {
@@ -42679,11 +42679,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_char2_1 = 645;
+    private final static int mExportReduceIdx_my_ushort_char2_1 = 645;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_char2_1(short[] in1, byte[] in2) {
@@ -42747,11 +42747,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_char4_0 = 646;
+    private final static int mExportReduceIdx_my_ushort_char4_0 = 646;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_char4_0(short[] in1, byte[] in2) {
@@ -42815,11 +42815,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_char4_1 = 647;
+    private final static int mExportReduceIdx_my_ushort_char4_1 = 647;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_char4_1(short[] in1, byte[] in2) {
@@ -42883,11 +42883,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_short_0 = 648;
+    private final static int mExportReduceIdx_my_ushort_short_0 = 648;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_short_0(short[] in1, short[] in2) {
@@ -42947,11 +42947,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_short_1 = 649;
+    private final static int mExportReduceIdx_my_ushort_short_1 = 649;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_short_1(short[] in1, short[] in2) {
@@ -43011,11 +43011,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_short2_0 = 650;
+    private final static int mExportReduceIdx_my_ushort_short2_0 = 650;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_short2_0(short[] in1, short[] in2) {
@@ -43079,11 +43079,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_short2_1 = 651;
+    private final static int mExportReduceIdx_my_ushort_short2_1 = 651;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_short2_1(short[] in1, short[] in2) {
@@ -43147,11 +43147,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_short4_0 = 652;
+    private final static int mExportReduceIdx_my_ushort_short4_0 = 652;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_short4_0(short[] in1, short[] in2) {
@@ -43215,11 +43215,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_short4_1 = 653;
+    private final static int mExportReduceIdx_my_ushort_short4_1 = 653;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_short4_1(short[] in1, short[] in2) {
@@ -43283,11 +43283,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_uchar_0 = 654;
+    private final static int mExportReduceIdx_my_ushort_uchar_0 = 654;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_uchar_0(short[] in1, byte[] in2) {
@@ -43347,11 +43347,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_uchar_1 = 655;
+    private final static int mExportReduceIdx_my_ushort_uchar_1 = 655;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_uchar_1(short[] in1, byte[] in2) {
@@ -43411,11 +43411,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_uchar2_0 = 656;
+    private final static int mExportReduceIdx_my_ushort_uchar2_0 = 656;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_uchar2_0(short[] in1, byte[] in2) {
@@ -43479,11 +43479,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_uchar2_1 = 657;
+    private final static int mExportReduceIdx_my_ushort_uchar2_1 = 657;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_uchar2_1(short[] in1, byte[] in2) {
@@ -43547,11 +43547,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_uchar4_0 = 658;
+    private final static int mExportReduceIdx_my_ushort_uchar4_0 = 658;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_uchar4_0(short[] in1, byte[] in2) {
@@ -43615,11 +43615,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_uchar4_1 = 659;
+    private final static int mExportReduceIdx_my_ushort_uchar4_1 = 659;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_uchar4_1(short[] in1, byte[] in2) {
@@ -43683,11 +43683,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_ushort_0 = 660;
+    private final static int mExportReduceIdx_my_ushort_ushort_0 = 660;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_ushort_0(short[] in1, short[] in2) {
@@ -43747,11 +43747,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_ushort_1 = 661;
+    private final static int mExportReduceIdx_my_ushort_ushort_1 = 661;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_ushort_1(short[] in1, short[] in2) {
@@ -43811,11 +43811,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_ushort2_0 = 662;
+    private final static int mExportReduceIdx_my_ushort_ushort2_0 = 662;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_ushort2_0(short[] in1, short[] in2) {
@@ -43879,11 +43879,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_ushort2_1 = 663;
+    private final static int mExportReduceIdx_my_ushort_ushort2_1 = 663;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort_ushort2_1(short[] in1, short[] in2) {
@@ -43947,11 +43947,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_ushort4_0 = 664;
+    private final static int mExportReduceIdx_my_ushort_ushort4_0 = 664;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_ushort4_0(short[] in1, short[] in2) {
@@ -44015,11 +44015,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_ushort4_1 = 665;
+    private final static int mExportReduceIdx_my_ushort_ushort4_1 = 665;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort_ushort4_1(short[] in1, short[] in2) {
@@ -44083,11 +44083,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_bool_0 = 666;
+    private final static int mExportReduceIdx_my_ushort_bool_0 = 666;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_bool_0(short[] in1, byte[] in2) {
@@ -44147,11 +44147,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_bool_1 = 667;
+    private final static int mExportReduceIdx_my_ushort_bool_1 = 667;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_ushort_bool_1(short[] in1, byte[] in2) {
@@ -44211,11 +44211,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_rs_matrix2x2_0 = 668;
+    private final static int mExportReduceIdx_my_ushort_rs_matrix2x2_0 = 668;
     // ain1 = "ushort a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_ushort_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -44245,11 +44245,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_rs_matrix2x2_1 = 669;
+    private final static int mExportReduceIdx_my_ushort_rs_matrix2x2_1 = 669;
     // ain1 = "ushort a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_ushort_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -44279,11 +44279,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_MyStruct_0 = 670;
+    private final static int mExportReduceIdx_my_ushort_MyStruct_0 = 670;
     // ain1 = "ushort a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_ushort_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -44316,11 +44316,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort_MyStruct_1 = 671;
+    private final static int mExportReduceIdx_my_ushort_MyStruct_1 = 671;
     // ain1 = "ushort a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_ushort_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -44353,11 +44353,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_half_0 = 672;
+    private final static int mExportReduceIdx_my_ushort2_half_0 = 672;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_half_0(short[] in1, short[] in2) {
@@ -44421,11 +44421,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_half_1 = 673;
+    private final static int mExportReduceIdx_my_ushort2_half_1 = 673;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_half_1(short[] in1, short[] in2) {
@@ -44489,11 +44489,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_half2_0 = 674;
+    private final static int mExportReduceIdx_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) {
@@ -44561,11 +44561,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_half2_1 = 675;
+    private final static int mExportReduceIdx_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) {
@@ -44633,11 +44633,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_half4_0 = 676;
+    private final static int mExportReduceIdx_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) {
@@ -44705,11 +44705,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_half4_1 = 677;
+    private final static int mExportReduceIdx_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) {
@@ -44777,11 +44777,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_float_0 = 678;
+    private final static int mExportReduceIdx_my_ushort2_float_0 = 678;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_float_0(short[] in1, float[] in2) {
@@ -44845,11 +44845,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_float_1 = 679;
+    private final static int mExportReduceIdx_my_ushort2_float_1 = 679;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_float_1(short[] in1, float[] in2) {
@@ -44913,11 +44913,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_float2_0 = 680;
+    private final static int mExportReduceIdx_my_ushort2_float2_0 = 680;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_float2_0(short[] in1, float[] in2) {
@@ -44985,11 +44985,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_float2_1 = 681;
+    private final static int mExportReduceIdx_my_ushort2_float2_1 = 681;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_float2_1(short[] in1, float[] in2) {
@@ -45057,11 +45057,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_float4_0 = 682;
+    private final static int mExportReduceIdx_my_ushort2_float4_0 = 682;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_float4_0(short[] in1, float[] in2) {
@@ -45129,11 +45129,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_float4_1 = 683;
+    private final static int mExportReduceIdx_my_ushort2_float4_1 = 683;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_float4_1(short[] in1, float[] in2) {
@@ -45201,11 +45201,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_char_0 = 684;
+    private final static int mExportReduceIdx_my_ushort2_char_0 = 684;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_char_0(short[] in1, byte[] in2) {
@@ -45269,11 +45269,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_char_1 = 685;
+    private final static int mExportReduceIdx_my_ushort2_char_1 = 685;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_char_1(short[] in1, byte[] in2) {
@@ -45337,11 +45337,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_char2_0 = 686;
+    private final static int mExportReduceIdx_my_ushort2_char2_0 = 686;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_char2_0(short[] in1, byte[] in2) {
@@ -45409,11 +45409,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_char2_1 = 687;
+    private final static int mExportReduceIdx_my_ushort2_char2_1 = 687;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_char2_1(short[] in1, byte[] in2) {
@@ -45481,11 +45481,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_char4_0 = 688;
+    private final static int mExportReduceIdx_my_ushort2_char4_0 = 688;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_char4_0(short[] in1, byte[] in2) {
@@ -45553,11 +45553,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_char4_1 = 689;
+    private final static int mExportReduceIdx_my_ushort2_char4_1 = 689;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_char4_1(short[] in1, byte[] in2) {
@@ -45625,11 +45625,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_short_0 = 690;
+    private final static int mExportReduceIdx_my_ushort2_short_0 = 690;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_short_0(short[] in1, short[] in2) {
@@ -45693,11 +45693,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_short_1 = 691;
+    private final static int mExportReduceIdx_my_ushort2_short_1 = 691;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_short_1(short[] in1, short[] in2) {
@@ -45761,11 +45761,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_short2_0 = 692;
+    private final static int mExportReduceIdx_my_ushort2_short2_0 = 692;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_short2_0(short[] in1, short[] in2) {
@@ -45833,11 +45833,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_short2_1 = 693;
+    private final static int mExportReduceIdx_my_ushort2_short2_1 = 693;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_short2_1(short[] in1, short[] in2) {
@@ -45905,11 +45905,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_short4_0 = 694;
+    private final static int mExportReduceIdx_my_ushort2_short4_0 = 694;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_short4_0(short[] in1, short[] in2) {
@@ -45977,11 +45977,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_short4_1 = 695;
+    private final static int mExportReduceIdx_my_ushort2_short4_1 = 695;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_short4_1(short[] in1, short[] in2) {
@@ -46049,11 +46049,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_uchar_0 = 696;
+    private final static int mExportReduceIdx_my_ushort2_uchar_0 = 696;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_uchar_0(short[] in1, byte[] in2) {
@@ -46117,11 +46117,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_uchar_1 = 697;
+    private final static int mExportReduceIdx_my_ushort2_uchar_1 = 697;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_uchar_1(short[] in1, byte[] in2) {
@@ -46185,11 +46185,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_uchar2_0 = 698;
+    private final static int mExportReduceIdx_my_ushort2_uchar2_0 = 698;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_uchar2_0(short[] in1, byte[] in2) {
@@ -46257,11 +46257,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_uchar2_1 = 699;
+    private final static int mExportReduceIdx_my_ushort2_uchar2_1 = 699;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_uchar2_1(short[] in1, byte[] in2) {
@@ -46329,11 +46329,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_uchar4_0 = 700;
+    private final static int mExportReduceIdx_my_ushort2_uchar4_0 = 700;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_uchar4_0(short[] in1, byte[] in2) {
@@ -46401,11 +46401,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_uchar4_1 = 701;
+    private final static int mExportReduceIdx_my_ushort2_uchar4_1 = 701;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_uchar4_1(short[] in1, byte[] in2) {
@@ -46473,11 +46473,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_ushort_0 = 702;
+    private final static int mExportReduceIdx_my_ushort2_ushort_0 = 702;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_ushort_0(short[] in1, short[] in2) {
@@ -46541,11 +46541,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_ushort_1 = 703;
+    private final static int mExportReduceIdx_my_ushort2_ushort_1 = 703;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_ushort_1(short[] in1, short[] in2) {
@@ -46609,11 +46609,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_ushort2_0 = 704;
+    private final static int mExportReduceIdx_my_ushort2_ushort2_0 = 704;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_ushort2_0(short[] in1, short[] in2) {
@@ -46681,11 +46681,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_ushort2_1 = 705;
+    private final static int mExportReduceIdx_my_ushort2_ushort2_1 = 705;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort2_ushort2_1(short[] in1, short[] in2) {
@@ -46753,11 +46753,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_ushort4_0 = 706;
+    private final static int mExportReduceIdx_my_ushort2_ushort4_0 = 706;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_ushort4_0(short[] in1, short[] in2) {
@@ -46825,11 +46825,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_ushort4_1 = 707;
+    private final static int mExportReduceIdx_my_ushort2_ushort4_1 = 707;
     // in1 = "a", flattened 2-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort2_ushort4_1(short[] in1, short[] in2) {
@@ -46897,11 +46897,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_bool_0 = 708;
+    private final static int mExportReduceIdx_my_ushort2_bool_0 = 708;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_bool_0(short[] in1, byte[] in2) {
@@ -46965,11 +46965,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_bool_1 = 709;
+    private final static int mExportReduceIdx_my_ushort2_bool_1 = 709;
     // in1 = "a", flattened 2-vectors
     // in2 = "b"
     public result_int reduce_my_ushort2_bool_1(short[] in1, byte[] in2) {
@@ -47033,11 +47033,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_rs_matrix2x2_0 = 710;
+    private final static int mExportReduceIdx_my_ushort2_rs_matrix2x2_0 = 710;
     // ain1 = "ushort2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_ushort2_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -47067,11 +47067,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_rs_matrix2x2_1 = 711;
+    private final static int mExportReduceIdx_my_ushort2_rs_matrix2x2_1 = 711;
     // ain1 = "ushort2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_ushort2_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -47101,11 +47101,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_MyStruct_0 = 712;
+    private final static int mExportReduceIdx_my_ushort2_MyStruct_0 = 712;
     // ain1 = "ushort2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_ushort2_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -47138,11 +47138,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2_MyStruct_1 = 713;
+    private final static int mExportReduceIdx_my_ushort2_MyStruct_1 = 713;
     // ain1 = "ushort2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_ushort2_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -47175,11 +47175,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_half_0 = 714;
+    private final static int mExportReduceIdx_my_ushort4_half_0 = 714;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_half_0(short[] in1, short[] in2) {
@@ -47243,11 +47243,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_half_1 = 715;
+    private final static int mExportReduceIdx_my_ushort4_half_1 = 715;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_half_1(short[] in1, short[] in2) {
@@ -47311,11 +47311,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_half2_0 = 716;
+    private final static int mExportReduceIdx_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) {
@@ -47383,11 +47383,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_half2_1 = 717;
+    private final static int mExportReduceIdx_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) {
@@ -47455,11 +47455,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_half4_0 = 718;
+    private final static int mExportReduceIdx_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) {
@@ -47527,11 +47527,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_half4_1 = 719;
+    private final static int mExportReduceIdx_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) {
@@ -47599,11 +47599,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_float_0 = 720;
+    private final static int mExportReduceIdx_my_ushort4_float_0 = 720;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_float_0(short[] in1, float[] in2) {
@@ -47667,11 +47667,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_float_1 = 721;
+    private final static int mExportReduceIdx_my_ushort4_float_1 = 721;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_float_1(short[] in1, float[] in2) {
@@ -47735,11 +47735,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_float2_0 = 722;
+    private final static int mExportReduceIdx_my_ushort4_float2_0 = 722;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_float2_0(short[] in1, float[] in2) {
@@ -47807,11 +47807,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_float2_1 = 723;
+    private final static int mExportReduceIdx_my_ushort4_float2_1 = 723;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_float2_1(short[] in1, float[] in2) {
@@ -47879,11 +47879,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_float4_0 = 724;
+    private final static int mExportReduceIdx_my_ushort4_float4_0 = 724;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_float4_0(short[] in1, float[] in2) {
@@ -47951,11 +47951,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_float4_1 = 725;
+    private final static int mExportReduceIdx_my_ushort4_float4_1 = 725;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_float4_1(short[] in1, float[] in2) {
@@ -48023,11 +48023,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_char_0 = 726;
+    private final static int mExportReduceIdx_my_ushort4_char_0 = 726;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_char_0(short[] in1, byte[] in2) {
@@ -48091,11 +48091,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_char_1 = 727;
+    private final static int mExportReduceIdx_my_ushort4_char_1 = 727;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_char_1(short[] in1, byte[] in2) {
@@ -48159,11 +48159,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_char2_0 = 728;
+    private final static int mExportReduceIdx_my_ushort4_char2_0 = 728;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_char2_0(short[] in1, byte[] in2) {
@@ -48231,11 +48231,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_char2_1 = 729;
+    private final static int mExportReduceIdx_my_ushort4_char2_1 = 729;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_char2_1(short[] in1, byte[] in2) {
@@ -48303,11 +48303,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_char4_0 = 730;
+    private final static int mExportReduceIdx_my_ushort4_char4_0 = 730;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_char4_0(short[] in1, byte[] in2) {
@@ -48375,11 +48375,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_char4_1 = 731;
+    private final static int mExportReduceIdx_my_ushort4_char4_1 = 731;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_char4_1(short[] in1, byte[] in2) {
@@ -48447,11 +48447,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_short_0 = 732;
+    private final static int mExportReduceIdx_my_ushort4_short_0 = 732;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_short_0(short[] in1, short[] in2) {
@@ -48515,11 +48515,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_short_1 = 733;
+    private final static int mExportReduceIdx_my_ushort4_short_1 = 733;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_short_1(short[] in1, short[] in2) {
@@ -48583,11 +48583,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_short2_0 = 734;
+    private final static int mExportReduceIdx_my_ushort4_short2_0 = 734;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_short2_0(short[] in1, short[] in2) {
@@ -48655,11 +48655,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_short2_1 = 735;
+    private final static int mExportReduceIdx_my_ushort4_short2_1 = 735;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_short2_1(short[] in1, short[] in2) {
@@ -48727,11 +48727,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_short4_0 = 736;
+    private final static int mExportReduceIdx_my_ushort4_short4_0 = 736;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_short4_0(short[] in1, short[] in2) {
@@ -48799,11 +48799,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_short4_1 = 737;
+    private final static int mExportReduceIdx_my_ushort4_short4_1 = 737;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_short4_1(short[] in1, short[] in2) {
@@ -48871,11 +48871,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_uchar_0 = 738;
+    private final static int mExportReduceIdx_my_ushort4_uchar_0 = 738;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_uchar_0(short[] in1, byte[] in2) {
@@ -48939,11 +48939,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_uchar_1 = 739;
+    private final static int mExportReduceIdx_my_ushort4_uchar_1 = 739;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_uchar_1(short[] in1, byte[] in2) {
@@ -49007,11 +49007,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_uchar2_0 = 740;
+    private final static int mExportReduceIdx_my_ushort4_uchar2_0 = 740;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_uchar2_0(short[] in1, byte[] in2) {
@@ -49079,11 +49079,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_uchar2_1 = 741;
+    private final static int mExportReduceIdx_my_ushort4_uchar2_1 = 741;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_uchar2_1(short[] in1, byte[] in2) {
@@ -49151,11 +49151,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_uchar4_0 = 742;
+    private final static int mExportReduceIdx_my_ushort4_uchar4_0 = 742;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_uchar4_0(short[] in1, byte[] in2) {
@@ -49223,11 +49223,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_uchar4_1 = 743;
+    private final static int mExportReduceIdx_my_ushort4_uchar4_1 = 743;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_uchar4_1(short[] in1, byte[] in2) {
@@ -49295,11 +49295,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_ushort_0 = 744;
+    private final static int mExportReduceIdx_my_ushort4_ushort_0 = 744;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_ushort_0(short[] in1, short[] in2) {
@@ -49363,11 +49363,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_ushort_1 = 745;
+    private final static int mExportReduceIdx_my_ushort4_ushort_1 = 745;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_ushort_1(short[] in1, short[] in2) {
@@ -49431,11 +49431,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_ushort2_0 = 746;
+    private final static int mExportReduceIdx_my_ushort4_ushort2_0 = 746;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_ushort2_0(short[] in1, short[] in2) {
@@ -49503,11 +49503,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_ushort2_1 = 747;
+    private final static int mExportReduceIdx_my_ushort4_ushort2_1 = 747;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_ushort4_ushort2_1(short[] in1, short[] in2) {
@@ -49575,11 +49575,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_ushort4_0 = 748;
+    private final static int mExportReduceIdx_my_ushort4_ushort4_0 = 748;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_ushort4_0(short[] in1, short[] in2) {
@@ -49647,11 +49647,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_ushort4_1 = 749;
+    private final static int mExportReduceIdx_my_ushort4_ushort4_1 = 749;
     // in1 = "a", flattened 4-vectors
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_ushort4_ushort4_1(short[] in1, short[] in2) {
@@ -49719,11 +49719,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_bool_0 = 750;
+    private final static int mExportReduceIdx_my_ushort4_bool_0 = 750;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_bool_0(short[] in1, byte[] in2) {
@@ -49787,11 +49787,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_bool_1 = 751;
+    private final static int mExportReduceIdx_my_ushort4_bool_1 = 751;
     // in1 = "a", flattened 4-vectors
     // in2 = "b"
     public result_int reduce_my_ushort4_bool_1(short[] in1, byte[] in2) {
@@ -49855,11 +49855,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_rs_matrix2x2_0 = 752;
+    private final static int mExportReduceIdx_my_ushort4_rs_matrix2x2_0 = 752;
     // ain1 = "ushort4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_ushort4_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -49889,11 +49889,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_rs_matrix2x2_1 = 753;
+    private final static int mExportReduceIdx_my_ushort4_rs_matrix2x2_1 = 753;
     // ain1 = "ushort4 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_ushort4_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -49923,11 +49923,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_MyStruct_0 = 754;
+    private final static int mExportReduceIdx_my_ushort4_MyStruct_0 = 754;
     // ain1 = "ushort4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_ushort4_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -49960,11 +49960,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4_MyStruct_1 = 755;
+    private final static int mExportReduceIdx_my_ushort4_MyStruct_1 = 755;
     // ain1 = "ushort4 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_ushort4_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -49997,11 +49997,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_half_0 = 756;
+    private final static int mExportReduceIdx_my_bool_half_0 = 756;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_half_0(byte[] in1, short[] in2) {
@@ -50061,11 +50061,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_half_1 = 757;
+    private final static int mExportReduceIdx_my_bool_half_1 = 757;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_half_1(byte[] in1, short[] in2) {
@@ -50125,11 +50125,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_half2_0 = 758;
+    private final static int mExportReduceIdx_my_bool_half2_0 = 758;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_half2_0(byte[] in1, short[] in2) {
@@ -50193,11 +50193,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_half2_1 = 759;
+    private final static int mExportReduceIdx_my_bool_half2_1 = 759;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_half2_1(byte[] in1, short[] in2) {
@@ -50261,11 +50261,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_half4_0 = 760;
+    private final static int mExportReduceIdx_my_bool_half4_0 = 760;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_half4_0(byte[] in1, short[] in2) {
@@ -50329,11 +50329,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_half4_1 = 761;
+    private final static int mExportReduceIdx_my_bool_half4_1 = 761;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_half4_1(byte[] in1, short[] in2) {
@@ -50397,11 +50397,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_float_0 = 762;
+    private final static int mExportReduceIdx_my_bool_float_0 = 762;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_float_0(byte[] in1, float[] in2) {
@@ -50461,11 +50461,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_float_1 = 763;
+    private final static int mExportReduceIdx_my_bool_float_1 = 763;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_float_1(byte[] in1, float[] in2) {
@@ -50525,11 +50525,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_float2_0 = 764;
+    private final static int mExportReduceIdx_my_bool_float2_0 = 764;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_float2_0(byte[] in1, float[] in2) {
@@ -50593,11 +50593,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_float2_1 = 765;
+    private final static int mExportReduceIdx_my_bool_float2_1 = 765;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_float2_1(byte[] in1, float[] in2) {
@@ -50661,11 +50661,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_float4_0 = 766;
+    private final static int mExportReduceIdx_my_bool_float4_0 = 766;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_float4_0(byte[] in1, float[] in2) {
@@ -50729,11 +50729,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_float4_1 = 767;
+    private final static int mExportReduceIdx_my_bool_float4_1 = 767;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_float4_1(byte[] in1, float[] in2) {
@@ -50797,11 +50797,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_char_0 = 768;
+    private final static int mExportReduceIdx_my_bool_char_0 = 768;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_char_0(byte[] in1, byte[] in2) {
@@ -50861,11 +50861,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_char_1 = 769;
+    private final static int mExportReduceIdx_my_bool_char_1 = 769;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_char_1(byte[] in1, byte[] in2) {
@@ -50925,11 +50925,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_char2_0 = 770;
+    private final static int mExportReduceIdx_my_bool_char2_0 = 770;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_char2_0(byte[] in1, byte[] in2) {
@@ -50993,11 +50993,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_char2_1 = 771;
+    private final static int mExportReduceIdx_my_bool_char2_1 = 771;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_char2_1(byte[] in1, byte[] in2) {
@@ -51061,11 +51061,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_char4_0 = 772;
+    private final static int mExportReduceIdx_my_bool_char4_0 = 772;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_char4_0(byte[] in1, byte[] in2) {
@@ -51129,11 +51129,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_char4_1 = 773;
+    private final static int mExportReduceIdx_my_bool_char4_1 = 773;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_char4_1(byte[] in1, byte[] in2) {
@@ -51197,11 +51197,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_short_0 = 774;
+    private final static int mExportReduceIdx_my_bool_short_0 = 774;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_short_0(byte[] in1, short[] in2) {
@@ -51261,11 +51261,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_short_1 = 775;
+    private final static int mExportReduceIdx_my_bool_short_1 = 775;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_short_1(byte[] in1, short[] in2) {
@@ -51325,11 +51325,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_short2_0 = 776;
+    private final static int mExportReduceIdx_my_bool_short2_0 = 776;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_short2_0(byte[] in1, short[] in2) {
@@ -51393,11 +51393,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_short2_1 = 777;
+    private final static int mExportReduceIdx_my_bool_short2_1 = 777;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_short2_1(byte[] in1, short[] in2) {
@@ -51461,11 +51461,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_short4_0 = 778;
+    private final static int mExportReduceIdx_my_bool_short4_0 = 778;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_short4_0(byte[] in1, short[] in2) {
@@ -51529,11 +51529,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_short4_1 = 779;
+    private final static int mExportReduceIdx_my_bool_short4_1 = 779;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_short4_1(byte[] in1, short[] in2) {
@@ -51597,11 +51597,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_uchar_0 = 780;
+    private final static int mExportReduceIdx_my_bool_uchar_0 = 780;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_uchar_0(byte[] in1, byte[] in2) {
@@ -51661,11 +51661,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_uchar_1 = 781;
+    private final static int mExportReduceIdx_my_bool_uchar_1 = 781;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_uchar_1(byte[] in1, byte[] in2) {
@@ -51725,11 +51725,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_uchar2_0 = 782;
+    private final static int mExportReduceIdx_my_bool_uchar2_0 = 782;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_uchar2_0(byte[] in1, byte[] in2) {
@@ -51793,11 +51793,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_uchar2_1 = 783;
+    private final static int mExportReduceIdx_my_bool_uchar2_1 = 783;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_uchar2_1(byte[] in1, byte[] in2) {
@@ -51861,11 +51861,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_uchar4_0 = 784;
+    private final static int mExportReduceIdx_my_bool_uchar4_0 = 784;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_uchar4_0(byte[] in1, byte[] in2) {
@@ -51929,11 +51929,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_uchar4_1 = 785;
+    private final static int mExportReduceIdx_my_bool_uchar4_1 = 785;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_uchar4_1(byte[] in1, byte[] in2) {
@@ -51997,11 +51997,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_ushort_0 = 786;
+    private final static int mExportReduceIdx_my_bool_ushort_0 = 786;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_ushort_0(byte[] in1, short[] in2) {
@@ -52061,11 +52061,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_ushort_1 = 787;
+    private final static int mExportReduceIdx_my_bool_ushort_1 = 787;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_ushort_1(byte[] in1, short[] in2) {
@@ -52125,11 +52125,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_ushort2_0 = 788;
+    private final static int mExportReduceIdx_my_bool_ushort2_0 = 788;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_ushort2_0(byte[] in1, short[] in2) {
@@ -52193,11 +52193,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_ushort2_1 = 789;
+    private final static int mExportReduceIdx_my_bool_ushort2_1 = 789;
     // in1 = "a"
     // in2 = "b", flattened 2-vectors
     public result_int reduce_my_bool_ushort2_1(byte[] in1, short[] in2) {
@@ -52261,11 +52261,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_ushort4_0 = 790;
+    private final static int mExportReduceIdx_my_bool_ushort4_0 = 790;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_ushort4_0(byte[] in1, short[] in2) {
@@ -52329,11 +52329,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_ushort4_1 = 791;
+    private final static int mExportReduceIdx_my_bool_ushort4_1 = 791;
     // in1 = "a"
     // in2 = "b", flattened 4-vectors
     public result_int reduce_my_bool_ushort4_1(byte[] in1, short[] in2) {
@@ -52397,11 +52397,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_bool_0 = 792;
+    private final static int mExportReduceIdx_my_bool_bool_0 = 792;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_bool_0(byte[] in1, byte[] in2) {
@@ -52461,11 +52461,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_bool_1 = 793;
+    private final static int mExportReduceIdx_my_bool_bool_1 = 793;
     // in1 = "a"
     // in2 = "b"
     public result_int reduce_my_bool_bool_1(byte[] in1, byte[] in2) {
@@ -52525,11 +52525,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_rs_matrix2x2_0 = 794;
+    private final static int mExportReduceIdx_my_bool_rs_matrix2x2_0 = 794;
     // ain1 = "bool a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_bool_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -52559,11 +52559,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_rs_matrix2x2_1 = 795;
+    private final static int mExportReduceIdx_my_bool_rs_matrix2x2_1 = 795;
     // ain1 = "bool a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_bool_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -52593,11 +52593,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_MyStruct_0 = 796;
+    private final static int mExportReduceIdx_my_bool_MyStruct_0 = 796;
     // ain1 = "bool a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_bool_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -52630,11 +52630,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool_MyStruct_1 = 797;
+    private final static int mExportReduceIdx_my_bool_MyStruct_1 = 797;
     // ain1 = "bool a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_bool_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -52667,11 +52667,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_bool_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_half_0 = 798;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_half_0 = 798;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "half b"
     public result_int reduce_my_rs_matrix2x2_half_0(Allocation ain1, Allocation ain2) {
@@ -52701,11 +52701,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_half_1 = 799;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_half_1 = 799;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "half b"
     public result_int reduce_my_rs_matrix2x2_half_1(Allocation ain1, Allocation ain2) {
@@ -52735,11 +52735,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_half2_0 = 800;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_half2_0 = 800;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_rs_matrix2x2_half2_0(Allocation ain1, Allocation ain2) {
@@ -52769,11 +52769,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_half2_1 = 801;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_half2_1 = 801;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "half2 b"
     public result_int reduce_my_rs_matrix2x2_half2_1(Allocation ain1, Allocation ain2) {
@@ -52803,11 +52803,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_half4_0 = 802;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_half4_0 = 802;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_rs_matrix2x2_half4_0(Allocation ain1, Allocation ain2) {
@@ -52837,11 +52837,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_half4_1 = 803;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_half4_1 = 803;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "half4 b"
     public result_int reduce_my_rs_matrix2x2_half4_1(Allocation ain1, Allocation ain2) {
@@ -52871,11 +52871,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_float_0 = 804;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_float_0 = 804;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "float b"
     public result_int reduce_my_rs_matrix2x2_float_0(Allocation ain1, Allocation ain2) {
@@ -52905,11 +52905,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_float_1 = 805;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_float_1 = 805;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "float b"
     public result_int reduce_my_rs_matrix2x2_float_1(Allocation ain1, Allocation ain2) {
@@ -52939,11 +52939,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_float2_0 = 806;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_float2_0 = 806;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "float2 b"
     public result_int reduce_my_rs_matrix2x2_float2_0(Allocation ain1, Allocation ain2) {
@@ -52973,11 +52973,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_float2_1 = 807;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_float2_1 = 807;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "float2 b"
     public result_int reduce_my_rs_matrix2x2_float2_1(Allocation ain1, Allocation ain2) {
@@ -53007,11 +53007,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_float4_0 = 808;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_float4_0 = 808;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "float4 b"
     public result_int reduce_my_rs_matrix2x2_float4_0(Allocation ain1, Allocation ain2) {
@@ -53041,11 +53041,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_float4_1 = 809;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_float4_1 = 809;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "float4 b"
     public result_int reduce_my_rs_matrix2x2_float4_1(Allocation ain1, Allocation ain2) {
@@ -53075,11 +53075,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_char_0 = 810;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_char_0 = 810;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "char b"
     public result_int reduce_my_rs_matrix2x2_char_0(Allocation ain1, Allocation ain2) {
@@ -53109,11 +53109,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_char_1 = 811;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_char_1 = 811;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "char b"
     public result_int reduce_my_rs_matrix2x2_char_1(Allocation ain1, Allocation ain2) {
@@ -53143,11 +53143,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_char2_0 = 812;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_char2_0 = 812;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "char2 b"
     public result_int reduce_my_rs_matrix2x2_char2_0(Allocation ain1, Allocation ain2) {
@@ -53177,11 +53177,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_char2_1 = 813;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_char2_1 = 813;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "char2 b"
     public result_int reduce_my_rs_matrix2x2_char2_1(Allocation ain1, Allocation ain2) {
@@ -53211,11 +53211,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_char4_0 = 814;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_char4_0 = 814;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "char4 b"
     public result_int reduce_my_rs_matrix2x2_char4_0(Allocation ain1, Allocation ain2) {
@@ -53245,11 +53245,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_char4_1 = 815;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_char4_1 = 815;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "char4 b"
     public result_int reduce_my_rs_matrix2x2_char4_1(Allocation ain1, Allocation ain2) {
@@ -53279,11 +53279,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_short_0 = 816;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_short_0 = 816;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "short b"
     public result_int reduce_my_rs_matrix2x2_short_0(Allocation ain1, Allocation ain2) {
@@ -53313,11 +53313,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_short_1 = 817;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_short_1 = 817;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "short b"
     public result_int reduce_my_rs_matrix2x2_short_1(Allocation ain1, Allocation ain2) {
@@ -53347,11 +53347,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_short2_0 = 818;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_short2_0 = 818;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "short2 b"
     public result_int reduce_my_rs_matrix2x2_short2_0(Allocation ain1, Allocation ain2) {
@@ -53381,11 +53381,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_short2_1 = 819;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_short2_1 = 819;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "short2 b"
     public result_int reduce_my_rs_matrix2x2_short2_1(Allocation ain1, Allocation ain2) {
@@ -53415,11 +53415,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_short4_0 = 820;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_short4_0 = 820;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "short4 b"
     public result_int reduce_my_rs_matrix2x2_short4_0(Allocation ain1, Allocation ain2) {
@@ -53449,11 +53449,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_short4_1 = 821;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_short4_1 = 821;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "short4 b"
     public result_int reduce_my_rs_matrix2x2_short4_1(Allocation ain1, Allocation ain2) {
@@ -53483,11 +53483,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_uchar_0 = 822;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_uchar_0 = 822;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "uchar b"
     public result_int reduce_my_rs_matrix2x2_uchar_0(Allocation ain1, Allocation ain2) {
@@ -53517,11 +53517,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_uchar_1 = 823;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_uchar_1 = 823;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "uchar b"
     public result_int reduce_my_rs_matrix2x2_uchar_1(Allocation ain1, Allocation ain2) {
@@ -53551,11 +53551,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_uchar2_0 = 824;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_uchar2_0 = 824;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_rs_matrix2x2_uchar2_0(Allocation ain1, Allocation ain2) {
@@ -53585,11 +53585,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_uchar2_1 = 825;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_uchar2_1 = 825;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_rs_matrix2x2_uchar2_1(Allocation ain1, Allocation ain2) {
@@ -53619,11 +53619,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_uchar4_0 = 826;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_uchar4_0 = 826;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_rs_matrix2x2_uchar4_0(Allocation ain1, Allocation ain2) {
@@ -53653,11 +53653,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_uchar4_1 = 827;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_uchar4_1 = 827;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_rs_matrix2x2_uchar4_1(Allocation ain1, Allocation ain2) {
@@ -53687,11 +53687,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_ushort_0 = 828;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_ushort_0 = 828;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "ushort b"
     public result_int reduce_my_rs_matrix2x2_ushort_0(Allocation ain1, Allocation ain2) {
@@ -53721,11 +53721,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_ushort_1 = 829;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_ushort_1 = 829;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "ushort b"
     public result_int reduce_my_rs_matrix2x2_ushort_1(Allocation ain1, Allocation ain2) {
@@ -53755,11 +53755,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_ushort2_0 = 830;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_ushort2_0 = 830;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_rs_matrix2x2_ushort2_0(Allocation ain1, Allocation ain2) {
@@ -53789,11 +53789,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_ushort2_1 = 831;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_ushort2_1 = 831;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_rs_matrix2x2_ushort2_1(Allocation ain1, Allocation ain2) {
@@ -53823,11 +53823,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_ushort4_0 = 832;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_ushort4_0 = 832;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_rs_matrix2x2_ushort4_0(Allocation ain1, Allocation ain2) {
@@ -53857,11 +53857,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_ushort4_1 = 833;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_ushort4_1 = 833;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_rs_matrix2x2_ushort4_1(Allocation ain1, Allocation ain2) {
@@ -53891,11 +53891,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_bool_0 = 834;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_bool_0 = 834;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "bool b"
     public result_int reduce_my_rs_matrix2x2_bool_0(Allocation ain1, Allocation ain2) {
@@ -53925,11 +53925,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_bool_1 = 835;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_bool_1 = 835;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "bool b"
     public result_int reduce_my_rs_matrix2x2_bool_1(Allocation ain1, Allocation ain2) {
@@ -53959,11 +53959,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_rs_matrix2x2_0 = 836;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_rs_matrix2x2_0 = 836;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_rs_matrix2x2_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -53990,11 +53990,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_rs_matrix2x2_1 = 837;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_rs_matrix2x2_1 = 837;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_rs_matrix2x2_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -54021,11 +54021,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_MyStruct_0 = 838;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_MyStruct_0 = 838;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_rs_matrix2x2_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -54055,11 +54055,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_rs_matrix2x2_MyStruct_1 = 839;
+    private final static int mExportReduceIdx_my_rs_matrix2x2_MyStruct_1 = 839;
     // ain1 = "rs_matrix2x2 a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_rs_matrix2x2_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -54089,11 +54089,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_rs_matrix2x2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_rs_matrix2x2_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_half_0 = 840;
+    private final static int mExportReduceIdx_my_MyStruct_half_0 = 840;
     // ain1 = "/* struct <> */ a"
     // ain2 = "half b"
     public result_int reduce_my_MyStruct_half_0(Allocation ain1, Allocation ain2) {
@@ -54126,11 +54126,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_half_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_half_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_half_1 = 841;
+    private final static int mExportReduceIdx_my_MyStruct_half_1 = 841;
     // ain1 = "/* struct <> */ a"
     // ain2 = "half b"
     public result_int reduce_my_MyStruct_half_1(Allocation ain1, Allocation ain2) {
@@ -54163,11 +54163,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_half_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_half_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_half2_0 = 842;
+    private final static int mExportReduceIdx_my_MyStruct_half2_0 = 842;
     // ain1 = "/* struct <> */ a"
     // ain2 = "half2 b"
     public result_int reduce_my_MyStruct_half2_0(Allocation ain1, Allocation ain2) {
@@ -54200,11 +54200,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_half2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_half2_1 = 843;
+    private final static int mExportReduceIdx_my_MyStruct_half2_1 = 843;
     // ain1 = "/* struct <> */ a"
     // ain2 = "half2 b"
     public result_int reduce_my_MyStruct_half2_1(Allocation ain1, Allocation ain2) {
@@ -54237,11 +54237,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_half2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_half4_0 = 844;
+    private final static int mExportReduceIdx_my_MyStruct_half4_0 = 844;
     // ain1 = "/* struct <> */ a"
     // ain2 = "half4 b"
     public result_int reduce_my_MyStruct_half4_0(Allocation ain1, Allocation ain2) {
@@ -54274,11 +54274,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_half4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_half4_1 = 845;
+    private final static int mExportReduceIdx_my_MyStruct_half4_1 = 845;
     // ain1 = "/* struct <> */ a"
     // ain2 = "half4 b"
     public result_int reduce_my_MyStruct_half4_1(Allocation ain1, Allocation ain2) {
@@ -54311,11 +54311,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_half4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_float_0 = 846;
+    private final static int mExportReduceIdx_my_MyStruct_float_0 = 846;
     // ain1 = "/* struct <> */ a"
     // ain2 = "float b"
     public result_int reduce_my_MyStruct_float_0(Allocation ain1, Allocation ain2) {
@@ -54348,11 +54348,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_float_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_float_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_float_1 = 847;
+    private final static int mExportReduceIdx_my_MyStruct_float_1 = 847;
     // ain1 = "/* struct <> */ a"
     // ain2 = "float b"
     public result_int reduce_my_MyStruct_float_1(Allocation ain1, Allocation ain2) {
@@ -54385,11 +54385,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_float_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_float_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_float2_0 = 848;
+    private final static int mExportReduceIdx_my_MyStruct_float2_0 = 848;
     // ain1 = "/* struct <> */ a"
     // ain2 = "float2 b"
     public result_int reduce_my_MyStruct_float2_0(Allocation ain1, Allocation ain2) {
@@ -54422,11 +54422,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_float2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_float2_1 = 849;
+    private final static int mExportReduceIdx_my_MyStruct_float2_1 = 849;
     // ain1 = "/* struct <> */ a"
     // ain2 = "float2 b"
     public result_int reduce_my_MyStruct_float2_1(Allocation ain1, Allocation ain2) {
@@ -54459,11 +54459,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_float2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_float4_0 = 850;
+    private final static int mExportReduceIdx_my_MyStruct_float4_0 = 850;
     // ain1 = "/* struct <> */ a"
     // ain2 = "float4 b"
     public result_int reduce_my_MyStruct_float4_0(Allocation ain1, Allocation ain2) {
@@ -54496,11 +54496,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_float4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_float4_1 = 851;
+    private final static int mExportReduceIdx_my_MyStruct_float4_1 = 851;
     // ain1 = "/* struct <> */ a"
     // ain2 = "float4 b"
     public result_int reduce_my_MyStruct_float4_1(Allocation ain1, Allocation ain2) {
@@ -54533,11 +54533,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_float4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_char_0 = 852;
+    private final static int mExportReduceIdx_my_MyStruct_char_0 = 852;
     // ain1 = "/* struct <> */ a"
     // ain2 = "char b"
     public result_int reduce_my_MyStruct_char_0(Allocation ain1, Allocation ain2) {
@@ -54570,11 +54570,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_char_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_char_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_char_1 = 853;
+    private final static int mExportReduceIdx_my_MyStruct_char_1 = 853;
     // ain1 = "/* struct <> */ a"
     // ain2 = "char b"
     public result_int reduce_my_MyStruct_char_1(Allocation ain1, Allocation ain2) {
@@ -54607,11 +54607,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_char_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_char_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_char2_0 = 854;
+    private final static int mExportReduceIdx_my_MyStruct_char2_0 = 854;
     // ain1 = "/* struct <> */ a"
     // ain2 = "char2 b"
     public result_int reduce_my_MyStruct_char2_0(Allocation ain1, Allocation ain2) {
@@ -54644,11 +54644,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_char2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_char2_1 = 855;
+    private final static int mExportReduceIdx_my_MyStruct_char2_1 = 855;
     // ain1 = "/* struct <> */ a"
     // ain2 = "char2 b"
     public result_int reduce_my_MyStruct_char2_1(Allocation ain1, Allocation ain2) {
@@ -54681,11 +54681,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_char2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_char4_0 = 856;
+    private final static int mExportReduceIdx_my_MyStruct_char4_0 = 856;
     // ain1 = "/* struct <> */ a"
     // ain2 = "char4 b"
     public result_int reduce_my_MyStruct_char4_0(Allocation ain1, Allocation ain2) {
@@ -54718,11 +54718,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_char4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_char4_1 = 857;
+    private final static int mExportReduceIdx_my_MyStruct_char4_1 = 857;
     // ain1 = "/* struct <> */ a"
     // ain2 = "char4 b"
     public result_int reduce_my_MyStruct_char4_1(Allocation ain1, Allocation ain2) {
@@ -54755,11 +54755,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_char4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_short_0 = 858;
+    private final static int mExportReduceIdx_my_MyStruct_short_0 = 858;
     // ain1 = "/* struct <> */ a"
     // ain2 = "short b"
     public result_int reduce_my_MyStruct_short_0(Allocation ain1, Allocation ain2) {
@@ -54792,11 +54792,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_short_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_short_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_short_1 = 859;
+    private final static int mExportReduceIdx_my_MyStruct_short_1 = 859;
     // ain1 = "/* struct <> */ a"
     // ain2 = "short b"
     public result_int reduce_my_MyStruct_short_1(Allocation ain1, Allocation ain2) {
@@ -54829,11 +54829,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_short_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_short_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_short2_0 = 860;
+    private final static int mExportReduceIdx_my_MyStruct_short2_0 = 860;
     // ain1 = "/* struct <> */ a"
     // ain2 = "short2 b"
     public result_int reduce_my_MyStruct_short2_0(Allocation ain1, Allocation ain2) {
@@ -54866,11 +54866,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_short2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_short2_1 = 861;
+    private final static int mExportReduceIdx_my_MyStruct_short2_1 = 861;
     // ain1 = "/* struct <> */ a"
     // ain2 = "short2 b"
     public result_int reduce_my_MyStruct_short2_1(Allocation ain1, Allocation ain2) {
@@ -54903,11 +54903,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_short2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_short4_0 = 862;
+    private final static int mExportReduceIdx_my_MyStruct_short4_0 = 862;
     // ain1 = "/* struct <> */ a"
     // ain2 = "short4 b"
     public result_int reduce_my_MyStruct_short4_0(Allocation ain1, Allocation ain2) {
@@ -54940,11 +54940,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_short4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_short4_1 = 863;
+    private final static int mExportReduceIdx_my_MyStruct_short4_1 = 863;
     // ain1 = "/* struct <> */ a"
     // ain2 = "short4 b"
     public result_int reduce_my_MyStruct_short4_1(Allocation ain1, Allocation ain2) {
@@ -54977,11 +54977,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_short4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_uchar_0 = 864;
+    private final static int mExportReduceIdx_my_MyStruct_uchar_0 = 864;
     // ain1 = "/* struct <> */ a"
     // ain2 = "uchar b"
     public result_int reduce_my_MyStruct_uchar_0(Allocation ain1, Allocation ain2) {
@@ -55014,11 +55014,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_uchar_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_uchar_1 = 865;
+    private final static int mExportReduceIdx_my_MyStruct_uchar_1 = 865;
     // ain1 = "/* struct <> */ a"
     // ain2 = "uchar b"
     public result_int reduce_my_MyStruct_uchar_1(Allocation ain1, Allocation ain2) {
@@ -55051,11 +55051,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_uchar_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_uchar2_0 = 866;
+    private final static int mExportReduceIdx_my_MyStruct_uchar2_0 = 866;
     // ain1 = "/* struct <> */ a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_MyStruct_uchar2_0(Allocation ain1, Allocation ain2) {
@@ -55088,11 +55088,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_uchar2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_uchar2_1 = 867;
+    private final static int mExportReduceIdx_my_MyStruct_uchar2_1 = 867;
     // ain1 = "/* struct <> */ a"
     // ain2 = "uchar2 b"
     public result_int reduce_my_MyStruct_uchar2_1(Allocation ain1, Allocation ain2) {
@@ -55125,11 +55125,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_uchar2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_uchar4_0 = 868;
+    private final static int mExportReduceIdx_my_MyStruct_uchar4_0 = 868;
     // ain1 = "/* struct <> */ a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_MyStruct_uchar4_0(Allocation ain1, Allocation ain2) {
@@ -55162,11 +55162,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_uchar4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_uchar4_1 = 869;
+    private final static int mExportReduceIdx_my_MyStruct_uchar4_1 = 869;
     // ain1 = "/* struct <> */ a"
     // ain2 = "uchar4 b"
     public result_int reduce_my_MyStruct_uchar4_1(Allocation ain1, Allocation ain2) {
@@ -55199,11 +55199,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_uchar4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_ushort_0 = 870;
+    private final static int mExportReduceIdx_my_MyStruct_ushort_0 = 870;
     // ain1 = "/* struct <> */ a"
     // ain2 = "ushort b"
     public result_int reduce_my_MyStruct_ushort_0(Allocation ain1, Allocation ain2) {
@@ -55236,11 +55236,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_ushort_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_ushort_1 = 871;
+    private final static int mExportReduceIdx_my_MyStruct_ushort_1 = 871;
     // ain1 = "/* struct <> */ a"
     // ain2 = "ushort b"
     public result_int reduce_my_MyStruct_ushort_1(Allocation ain1, Allocation ain2) {
@@ -55273,11 +55273,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_ushort_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_ushort2_0 = 872;
+    private final static int mExportReduceIdx_my_MyStruct_ushort2_0 = 872;
     // ain1 = "/* struct <> */ a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_MyStruct_ushort2_0(Allocation ain1, Allocation ain2) {
@@ -55310,11 +55310,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_ushort2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_ushort2_1 = 873;
+    private final static int mExportReduceIdx_my_MyStruct_ushort2_1 = 873;
     // ain1 = "/* struct <> */ a"
     // ain2 = "ushort2 b"
     public result_int reduce_my_MyStruct_ushort2_1(Allocation ain1, Allocation ain2) {
@@ -55347,11 +55347,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_ushort2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_ushort4_0 = 874;
+    private final static int mExportReduceIdx_my_MyStruct_ushort4_0 = 874;
     // ain1 = "/* struct <> */ a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_MyStruct_ushort4_0(Allocation ain1, Allocation ain2) {
@@ -55384,11 +55384,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_ushort4_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_ushort4_1 = 875;
+    private final static int mExportReduceIdx_my_MyStruct_ushort4_1 = 875;
     // ain1 = "/* struct <> */ a"
     // ain2 = "ushort4 b"
     public result_int reduce_my_MyStruct_ushort4_1(Allocation ain1, Allocation ain2) {
@@ -55421,11 +55421,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_ushort4_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_bool_0 = 876;
+    private final static int mExportReduceIdx_my_MyStruct_bool_0 = 876;
     // ain1 = "/* struct <> */ a"
     // ain2 = "bool b"
     public result_int reduce_my_MyStruct_bool_0(Allocation ain1, Allocation ain2) {
@@ -55458,11 +55458,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_bool_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_bool_1 = 877;
+    private final static int mExportReduceIdx_my_MyStruct_bool_1 = 877;
     // ain1 = "/* struct <> */ a"
     // ain2 = "bool b"
     public result_int reduce_my_MyStruct_bool_1(Allocation ain1, Allocation ain2) {
@@ -55495,11 +55495,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_bool_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_rs_matrix2x2_0 = 878;
+    private final static int mExportReduceIdx_my_MyStruct_rs_matrix2x2_0 = 878;
     // ain1 = "/* struct <> */ a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_MyStruct_rs_matrix2x2_0(Allocation ain1, Allocation ain2) {
@@ -55529,11 +55529,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_rs_matrix2x2_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_rs_matrix2x2_1 = 879;
+    private final static int mExportReduceIdx_my_MyStruct_rs_matrix2x2_1 = 879;
     // ain1 = "/* struct <> */ a"
     // ain2 = "rs_matrix2x2 b"
     public result_int reduce_my_MyStruct_rs_matrix2x2_1(Allocation ain1, Allocation ain2) {
@@ -55563,11 +55563,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_rs_matrix2x2_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_MyStruct_0 = 880;
+    private final static int mExportReduceIdx_my_MyStruct_MyStruct_0 = 880;
     // ain1 = "/* struct <> */ a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_MyStruct_MyStruct_0(Allocation ain1, Allocation ain2) {
@@ -55600,11 +55600,11 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_MyStruct_0, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_MyStruct_MyStruct_1 = 881;
+    private final static int mExportReduceIdx_my_MyStruct_MyStruct_1 = 881;
     // ain1 = "/* struct <> */ a"
     // ain2 = "/* struct <> */ b"
     public result_int reduce_my_MyStruct_MyStruct_1(Allocation ain1, Allocation ain2) {
@@ -55637,7 +55637,7 @@
 
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_MyStruct_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
+        reduce(mExportReduceIdx_my_MyStruct_MyStruct_1, new Allocation[]{ain1, ain2}, aout, sc);
         return new result_int(aout);
     }
 
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 49ca526..c1bd6d5 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
@@ -2712,7 +2712,7 @@
         private Int4 mResult;
     }
 
-    private final static int mExportReduceNewIdx_my_half = 0;
+    private final static int mExportReduceIdx_my_half = 0;
     // in1 = "val"
     public result_half reduce_my_half(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2741,11 +2741,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F16, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half, new Allocation[]{ain1}, aout, sc);
         return new result_half(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half2 = 1;
+    private final static int mExportReduceIdx_my_half2 = 1;
     // in1 = "val", flattened 2-vectors
     public result_half2 reduce_my_half2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2778,11 +2778,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half2, new Allocation[]{ain1}, aout, sc);
         return new result_half2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_half4 = 2;
+    private final static int mExportReduceIdx_my_half4 = 2;
     // in1 = "val", flattened 4-vectors
     public result_half4 reduce_my_half4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2815,11 +2815,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_half4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_half4, new Allocation[]{ain1}, aout, sc);
         return new result_half4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_half = 3;
+    private final static int mExportReduceIdx_my_array_half = 3;
     // in1 = "val"
     public resultArray7_half reduce_my_array_half(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2848,11 +2848,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F16, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_half, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_half, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_half(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_half2 = 4;
+    private final static int mExportReduceIdx_my_array_half2 = 4;
     // in1 = "val", flattened 2-vectors
     public resultArray7_half2 reduce_my_array_half2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2885,11 +2885,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_half2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_half2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_half2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_half4 = 5;
+    private final static int mExportReduceIdx_my_array_half4 = 5;
     // in1 = "val", flattened 4-vectors
     public resultArray7_half4 reduce_my_array_half4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -2922,11 +2922,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_half4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_half4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_half4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float = 6;
+    private final static int mExportReduceIdx_my_float = 6;
     // in1 = "val"
     public result_float reduce_my_float(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2955,11 +2955,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float, new Allocation[]{ain1}, aout, sc);
         return new result_float(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float2 = 7;
+    private final static int mExportReduceIdx_my_float2 = 7;
     // in1 = "val", flattened 2-vectors
     public result_float2 reduce_my_float2(float[] in1) {
         // Verify that "in1" is non-null.
@@ -2992,11 +2992,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float2, new Allocation[]{ain1}, aout, sc);
         return new result_float2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_float4 = 8;
+    private final static int mExportReduceIdx_my_float4 = 8;
     // in1 = "val", flattened 4-vectors
     public result_float4 reduce_my_float4(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3029,11 +3029,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F32_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_float4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_float4, new Allocation[]{ain1}, aout, sc);
         return new result_float4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float = 9;
+    private final static int mExportReduceIdx_my_array_float = 9;
     // in1 = "val"
     public resultArray7_float reduce_my_array_float(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3062,11 +3062,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F32, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_float, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_float, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_float(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float2 = 10;
+    private final static int mExportReduceIdx_my_array_float2 = 10;
     // in1 = "val", flattened 2-vectors
     public resultArray7_float2 reduce_my_array_float2(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3099,11 +3099,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F32_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_float2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_float2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_float2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_float4 = 11;
+    private final static int mExportReduceIdx_my_array_float4 = 11;
     // in1 = "val", flattened 4-vectors
     public resultArray7_float4 reduce_my_array_float4(float[] in1) {
         // Verify that "in1" is non-null.
@@ -3136,11 +3136,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F32_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_float4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_float4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_float4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double = 12;
+    private final static int mExportReduceIdx_my_double = 12;
     // in1 = "val"
     public result_double reduce_my_double(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3169,11 +3169,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F64, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double, new Allocation[]{ain1}, aout, sc);
         return new result_double(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double2 = 13;
+    private final static int mExportReduceIdx_my_double2 = 13;
     // in1 = "val", flattened 2-vectors
     public result_double2 reduce_my_double2(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3206,11 +3206,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F64_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double2, new Allocation[]{ain1}, aout, sc);
         return new result_double2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_double4 = 14;
+    private final static int mExportReduceIdx_my_double4 = 14;
     // in1 = "val", flattened 4-vectors
     public result_double4 reduce_my_double4(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3243,11 +3243,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F64_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_double4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_double4, new Allocation[]{ain1}, aout, sc);
         return new result_double4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double = 15;
+    private final static int mExportReduceIdx_my_array_double = 15;
     // in1 = "val"
     public resultArray7_double reduce_my_array_double(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3276,11 +3276,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F64, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_double, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_double, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_double(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double2 = 16;
+    private final static int mExportReduceIdx_my_array_double2 = 16;
     // in1 = "val", flattened 2-vectors
     public resultArray7_double2 reduce_my_array_double2(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3313,11 +3313,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F64_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_double2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_double2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_double2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_double4 = 17;
+    private final static int mExportReduceIdx_my_array_double4 = 17;
     // in1 = "val", flattened 4-vectors
     public resultArray7_double4 reduce_my_array_double4(double[] in1) {
         // Verify that "in1" is non-null.
@@ -3350,11 +3350,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __F64_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_double4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_double4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_double4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char = 18;
+    private final static int mExportReduceIdx_my_char = 18;
     // in1 = "val"
     public result_char reduce_my_char(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -3383,11 +3383,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I8, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char, new Allocation[]{ain1}, aout, sc);
         return new result_char(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char2 = 19;
+    private final static int mExportReduceIdx_my_char2 = 19;
     // in1 = "val", flattened 2-vectors
     public result_char2 reduce_my_char2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -3420,11 +3420,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I8_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char2, new Allocation[]{ain1}, aout, sc);
         return new result_char2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_char4 = 20;
+    private final static int mExportReduceIdx_my_char4 = 20;
     // in1 = "val", flattened 4-vectors
     public result_char4 reduce_my_char4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -3457,11 +3457,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I8_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_char4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_char4, new Allocation[]{ain1}, aout, sc);
         return new result_char4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char = 21;
+    private final static int mExportReduceIdx_my_array_char = 21;
     // in1 = "val"
     public resultArray7_char reduce_my_array_char(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -3490,11 +3490,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I8, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_char, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_char, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_char(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char2 = 22;
+    private final static int mExportReduceIdx_my_array_char2 = 22;
     // in1 = "val", flattened 2-vectors
     public resultArray7_char2 reduce_my_array_char2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -3527,11 +3527,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I8_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_char2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_char2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_char2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_char4 = 23;
+    private final static int mExportReduceIdx_my_array_char4 = 23;
     // in1 = "val", flattened 4-vectors
     public resultArray7_char4 reduce_my_array_char4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -3564,11 +3564,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I8_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_char4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_char4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_char4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short = 24;
+    private final static int mExportReduceIdx_my_short = 24;
     // in1 = "val"
     public result_short reduce_my_short(short[] in1) {
         // Verify that "in1" is non-null.
@@ -3597,11 +3597,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I16, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short, new Allocation[]{ain1}, aout, sc);
         return new result_short(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short2 = 25;
+    private final static int mExportReduceIdx_my_short2 = 25;
     // in1 = "val", flattened 2-vectors
     public result_short2 reduce_my_short2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -3634,11 +3634,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I16_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short2, new Allocation[]{ain1}, aout, sc);
         return new result_short2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_short4 = 26;
+    private final static int mExportReduceIdx_my_short4 = 26;
     // in1 = "val", flattened 4-vectors
     public result_short4 reduce_my_short4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -3671,11 +3671,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I16_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_short4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_short4, new Allocation[]{ain1}, aout, sc);
         return new result_short4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short = 27;
+    private final static int mExportReduceIdx_my_array_short = 27;
     // in1 = "val"
     public resultArray7_short reduce_my_array_short(short[] in1) {
         // Verify that "in1" is non-null.
@@ -3704,11 +3704,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I16, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_short, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_short, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_short(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short2 = 28;
+    private final static int mExportReduceIdx_my_array_short2 = 28;
     // in1 = "val", flattened 2-vectors
     public resultArray7_short2 reduce_my_array_short2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -3741,11 +3741,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I16_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_short2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_short2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_short2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_short4 = 29;
+    private final static int mExportReduceIdx_my_array_short4 = 29;
     // in1 = "val", flattened 4-vectors
     public resultArray7_short4 reduce_my_array_short4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -3778,11 +3778,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I16_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_short4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_short4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_short4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int = 30;
+    private final static int mExportReduceIdx_my_int = 30;
     // in1 = "val"
     public result_int reduce_my_int(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3811,11 +3811,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int2 = 31;
+    private final static int mExportReduceIdx_my_int2 = 31;
     // in1 = "val", flattened 2-vectors
     public result_int2 reduce_my_int2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3848,11 +3848,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int2, new Allocation[]{ain1}, aout, sc);
         return new result_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_int4 = 32;
+    private final static int mExportReduceIdx_my_int4 = 32;
     // in1 = "val", flattened 4-vectors
     public result_int4 reduce_my_int4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3885,11 +3885,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_int4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_int4, new Allocation[]{ain1}, aout, sc);
         return new result_int4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int = 33;
+    private final static int mExportReduceIdx_my_array_int = 33;
     // in1 = "val"
     public resultArray7_int reduce_my_array_int(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3918,11 +3918,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_int, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_int, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_int(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int2 = 34;
+    private final static int mExportReduceIdx_my_array_int2 = 34;
     // in1 = "val", flattened 2-vectors
     public resultArray7_int2 reduce_my_array_int2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3955,11 +3955,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_int2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_int2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_int2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_int4 = 35;
+    private final static int mExportReduceIdx_my_array_int4 = 35;
     // in1 = "val", flattened 4-vectors
     public resultArray7_int4 reduce_my_array_int4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -3992,11 +3992,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_int4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_int4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_int4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long = 36;
+    private final static int mExportReduceIdx_my_long = 36;
     // in1 = "val"
     public result_long reduce_my_long(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4025,11 +4025,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I64, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long, new Allocation[]{ain1}, aout, sc);
         return new result_long(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long2 = 37;
+    private final static int mExportReduceIdx_my_long2 = 37;
     // in1 = "val", flattened 2-vectors
     public result_long2 reduce_my_long2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4062,11 +4062,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I64_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long2, new Allocation[]{ain1}, aout, sc);
         return new result_long2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_long4 = 38;
+    private final static int mExportReduceIdx_my_long4 = 38;
     // in1 = "val", flattened 4-vectors
     public result_long4 reduce_my_long4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4099,11 +4099,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I64_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_long4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_long4, new Allocation[]{ain1}, aout, sc);
         return new result_long4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long = 39;
+    private final static int mExportReduceIdx_my_array_long = 39;
     // in1 = "val"
     public resultArray7_long reduce_my_array_long(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4132,11 +4132,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I64, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_long, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_long, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_long(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long2 = 40;
+    private final static int mExportReduceIdx_my_array_long2 = 40;
     // in1 = "val", flattened 2-vectors
     public resultArray7_long2 reduce_my_array_long2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4169,11 +4169,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I64_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_long2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_long2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_long2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_long4 = 41;
+    private final static int mExportReduceIdx_my_array_long4 = 41;
     // in1 = "val", flattened 4-vectors
     public resultArray7_long4 reduce_my_array_long4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4206,11 +4206,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I64_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_long4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_long4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_long4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar = 42;
+    private final static int mExportReduceIdx_my_uchar = 42;
     // in1 = "val"
     public result_uchar reduce_my_uchar(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -4239,11 +4239,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U8, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar, new Allocation[]{ain1}, aout, sc);
         return new result_uchar(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar2 = 43;
+    private final static int mExportReduceIdx_my_uchar2 = 43;
     // in1 = "val", flattened 2-vectors
     public result_uchar2 reduce_my_uchar2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -4276,11 +4276,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U8_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar2, new Allocation[]{ain1}, aout, sc);
         return new result_uchar2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uchar4 = 44;
+    private final static int mExportReduceIdx_my_uchar4 = 44;
     // in1 = "val", flattened 4-vectors
     public result_uchar4 reduce_my_uchar4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -4313,11 +4313,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U8_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uchar4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uchar4, new Allocation[]{ain1}, aout, sc);
         return new result_uchar4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar = 45;
+    private final static int mExportReduceIdx_my_array_uchar = 45;
     // in1 = "val"
     public resultArray7_uchar reduce_my_array_uchar(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -4346,11 +4346,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U8, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uchar, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uchar, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_uchar(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar2 = 46;
+    private final static int mExportReduceIdx_my_array_uchar2 = 46;
     // in1 = "val", flattened 2-vectors
     public resultArray7_uchar2 reduce_my_array_uchar2(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -4383,11 +4383,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U8_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uchar2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uchar2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_uchar2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uchar4 = 47;
+    private final static int mExportReduceIdx_my_array_uchar4 = 47;
     // in1 = "val", flattened 4-vectors
     public resultArray7_uchar4 reduce_my_array_uchar4(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -4420,11 +4420,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U8_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uchar4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uchar4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_uchar4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort = 48;
+    private final static int mExportReduceIdx_my_ushort = 48;
     // in1 = "val"
     public result_ushort reduce_my_ushort(short[] in1) {
         // Verify that "in1" is non-null.
@@ -4453,11 +4453,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U16, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort, new Allocation[]{ain1}, aout, sc);
         return new result_ushort(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort2 = 49;
+    private final static int mExportReduceIdx_my_ushort2 = 49;
     // in1 = "val", flattened 2-vectors
     public result_ushort2 reduce_my_ushort2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -4490,11 +4490,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U16_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort2, new Allocation[]{ain1}, aout, sc);
         return new result_ushort2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ushort4 = 50;
+    private final static int mExportReduceIdx_my_ushort4 = 50;
     // in1 = "val", flattened 4-vectors
     public result_ushort4 reduce_my_ushort4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -4527,11 +4527,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U16_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ushort4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ushort4, new Allocation[]{ain1}, aout, sc);
         return new result_ushort4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort = 51;
+    private final static int mExportReduceIdx_my_array_ushort = 51;
     // in1 = "val"
     public resultArray7_ushort reduce_my_array_ushort(short[] in1) {
         // Verify that "in1" is non-null.
@@ -4560,11 +4560,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U16, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ushort, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ushort, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_ushort(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort2 = 52;
+    private final static int mExportReduceIdx_my_array_ushort2 = 52;
     // in1 = "val", flattened 2-vectors
     public resultArray7_ushort2 reduce_my_array_ushort2(short[] in1) {
         // Verify that "in1" is non-null.
@@ -4597,11 +4597,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U16_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ushort2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ushort2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_ushort2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ushort4 = 53;
+    private final static int mExportReduceIdx_my_array_ushort4 = 53;
     // in1 = "val", flattened 4-vectors
     public resultArray7_ushort4 reduce_my_array_ushort4(short[] in1) {
         // Verify that "in1" is non-null.
@@ -4634,11 +4634,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U16_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ushort4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ushort4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_ushort4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint = 54;
+    private final static int mExportReduceIdx_my_uint = 54;
     // in1 = "val"
     public result_uint reduce_my_uint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -4667,11 +4667,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint, new Allocation[]{ain1}, aout, sc);
         return new result_uint(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint2 = 55;
+    private final static int mExportReduceIdx_my_uint2 = 55;
     // in1 = "val", flattened 2-vectors
     public result_uint2 reduce_my_uint2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -4704,11 +4704,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint2, new Allocation[]{ain1}, aout, sc);
         return new result_uint2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_uint4 = 56;
+    private final static int mExportReduceIdx_my_uint4 = 56;
     // in1 = "val", flattened 4-vectors
     public result_uint4 reduce_my_uint4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -4741,11 +4741,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_uint4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_uint4, new Allocation[]{ain1}, aout, sc);
         return new result_uint4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint = 57;
+    private final static int mExportReduceIdx_my_array_uint = 57;
     // in1 = "val"
     public resultArray7_uint reduce_my_array_uint(int[] in1) {
         // Verify that "in1" is non-null.
@@ -4774,11 +4774,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uint, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uint, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_uint(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint2 = 58;
+    private final static int mExportReduceIdx_my_array_uint2 = 58;
     // in1 = "val", flattened 2-vectors
     public resultArray7_uint2 reduce_my_array_uint2(int[] in1) {
         // Verify that "in1" is non-null.
@@ -4811,11 +4811,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uint2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uint2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_uint2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_uint4 = 59;
+    private final static int mExportReduceIdx_my_array_uint4 = 59;
     // in1 = "val", flattened 4-vectors
     public resultArray7_uint4 reduce_my_array_uint4(int[] in1) {
         // Verify that "in1" is non-null.
@@ -4848,11 +4848,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U32_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_uint4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_uint4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_uint4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong = 60;
+    private final static int mExportReduceIdx_my_ulong = 60;
     // in1 = "val"
     public result_ulong reduce_my_ulong(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4881,11 +4881,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U64, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong, new Allocation[]{ain1}, aout, sc);
         return new result_ulong(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong2 = 61;
+    private final static int mExportReduceIdx_my_ulong2 = 61;
     // in1 = "val", flattened 2-vectors
     public result_ulong2 reduce_my_ulong2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4918,11 +4918,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U64_2, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong2, new Allocation[]{ain1}, aout, sc);
         return new result_ulong2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_ulong4 = 62;
+    private final static int mExportReduceIdx_my_ulong4 = 62;
     // in1 = "val", flattened 4-vectors
     public result_ulong4 reduce_my_ulong4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4955,11 +4955,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U64_4, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_ulong4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_ulong4, new Allocation[]{ain1}, aout, sc);
         return new result_ulong4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong = 63;
+    private final static int mExportReduceIdx_my_array_ulong = 63;
     // in1 = "val"
     public resultArray7_ulong reduce_my_array_ulong(long[] in1) {
         // Verify that "in1" is non-null.
@@ -4988,11 +4988,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U64, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ulong, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ulong, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_ulong(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong2 = 64;
+    private final static int mExportReduceIdx_my_array_ulong2 = 64;
     // in1 = "val", flattened 2-vectors
     public resultArray7_ulong2 reduce_my_array_ulong2(long[] in1) {
         // Verify that "in1" is non-null.
@@ -5025,11 +5025,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U64_2, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ulong2, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ulong2, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_ulong2(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_ulong4 = 65;
+    private final static int mExportReduceIdx_my_array_ulong4 = 65;
     // in1 = "val", flattened 4-vectors
     public resultArray7_ulong4 reduce_my_array_ulong4(long[] in1) {
         // Verify that "in1" is non-null.
@@ -5062,11 +5062,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __U64_4, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_ulong4, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_ulong4, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_ulong4(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_bool = 66;
+    private final static int mExportReduceIdx_my_bool = 66;
     // in1 = "val"
     public result_bool reduce_my_bool(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5095,11 +5095,11 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __BOOLEAN, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_bool, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_bool, new Allocation[]{ain1}, aout, sc);
         return new result_bool(aout);
     }
 
-    private final static int mExportReduceNewIdx_my_array_bool = 67;
+    private final static int mExportReduceIdx_my_array_bool = 67;
     // in1 = "val"
     public resultArray7_bool reduce_my_array_bool(byte[] in1) {
         // Verify that "in1" is non-null.
@@ -5128,7 +5128,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __BOOLEAN, 7);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_my_array_bool, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_my_array_bool, new Allocation[]{ain1}, aout, sc);
         return new resultArray7_bool(aout);
     }
 
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
index 3545371..983ea39 100644
--- a/tests/P_reduce_general_struct/ScriptC_reduce_general_struct.java.expect
+++ b/tests/P_reduce_general_struct/ScriptC_reduce_general_struct.java.expect
@@ -79,7 +79,7 @@
         private int mResult;
     }
 
-    private final static int mExportReduceNewIdx_inStruct = 0;
+    private final static int mExportReduceIdx_inStruct = 0;
     // ain1 = "/* struct <> */ val"
     public result_int reduce_inStruct(Allocation ain1) {
         return reduce_inStruct(ain1, null);
@@ -93,7 +93,7 @@
         }
         Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
         aout.setAutoPadding(true);
-        reduce(mExportReduceNewIdx_inStruct, new Allocation[]{ain1}, aout, sc);
+        reduce(mExportReduceIdx_inStruct, new Allocation[]{ain1}, aout, sc);
         return new result_int(aout);
     }
 
diff --git a/tests/P_reduce_ignore_cv/reduce_ignore_cv.rs b/tests/P_reduce_ignore_cv/reduce_ignore_cv.rs
deleted file mode 100644
index 0a055ca..0000000
--- a/tests/P_reduce_ignore_cv/reduce_ignore_cv.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// -target-api 0
-#pragma version(1)
-#pragma rs java_package_name(foo)
-
-typedef struct foo {
-  int x[10];
-} foo;
-
-foo __attribute__((kernel("reduce"))) add_foo_a(const foo a, const foo b) {
-  foo tmp = a;
-  for (int i = 0; i < 10; ++i)
-    tmp.x[i] += b.x[i];
-  return tmp;
-}
-
diff --git a/tests/P_reduce_ignore_cv/stderr.txt.expect b/tests/P_reduce_ignore_cv/stderr.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/P_reduce_ignore_cv/stderr.txt.expect
+++ /dev/null
diff --git a/tests/P_reduce_ignore_cv/stdout.txt.expect b/tests/P_reduce_ignore_cv/stdout.txt.expect
deleted file mode 100644
index e69de29..0000000
--- a/tests/P_reduce_ignore_cv/stdout.txt.expect
+++ /dev/null