1/*
2 * Copyright (C) 2011-2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*
18 * This file is auto-generated. DO NOT MODIFY!
19 * The source Renderscript file: reduce_general_result.rs
20 */
21
22package result;
23
24import android.renderscript.*;
25import result.reduce_general_resultBitCode;
26
27/**
28 * @hide
29 */
30public class ScriptC_reduce_general_result extends ScriptC {
31    private static final String __rs_resource_name = "reduce_general_result";
32    // Constructor
33    public  ScriptC_reduce_general_result(RenderScript rs) {
34        super(rs,
35              __rs_resource_name,
36              reduce_general_resultBitCode.getBitCode32(),
37              reduce_general_resultBitCode.getBitCode64());
38        mRSLocal = rs;
39        __F16 = Element.F16(rs);
40        __F16_2 = Element.F16_2(rs);
41        __F16_4 = Element.F16_4(rs);
42        __F32 = Element.F32(rs);
43        __F32_2 = Element.F32_2(rs);
44        __F32_4 = Element.F32_4(rs);
45        __F64 = Element.F64(rs);
46        __F64_2 = Element.F64_2(rs);
47        __F64_4 = Element.F64_4(rs);
48        __I8 = Element.I8(rs);
49        __I8_2 = Element.I8_2(rs);
50        __I8_4 = Element.I8_4(rs);
51        __I16 = Element.I16(rs);
52        __I16_2 = Element.I16_2(rs);
53        __I16_4 = Element.I16_4(rs);
54        __I32 = Element.I32(rs);
55        __I32_2 = Element.I32_2(rs);
56        __I32_4 = Element.I32_4(rs);
57        __I64 = Element.I64(rs);
58        __I64_2 = Element.I64_2(rs);
59        __I64_4 = Element.I64_4(rs);
60        __U8 = Element.U8(rs);
61        __U8_2 = Element.U8_2(rs);
62        __U8_4 = Element.U8_4(rs);
63        __U16 = Element.U16(rs);
64        __U16_2 = Element.U16_2(rs);
65        __U16_4 = Element.U16_4(rs);
66        __U32 = Element.U32(rs);
67        __U32_2 = Element.U32_2(rs);
68        __U32_4 = Element.U32_4(rs);
69        __U64 = Element.U64(rs);
70        __U64_2 = Element.U64_2(rs);
71        __U64_4 = Element.U64_4(rs);
72        __BOOLEAN = Element.BOOLEAN(rs);
73    }
74
75    private Element __BOOLEAN;
76    private Element __F16;
77    private Element __F16_2;
78    private Element __F16_4;
79    private Element __F32;
80    private Element __F32_2;
81    private Element __F32_4;
82    private Element __F64;
83    private Element __F64_2;
84    private Element __F64_4;
85    private Element __I16;
86    private Element __I16_2;
87    private Element __I16_4;
88    private Element __I32;
89    private Element __I32_2;
90    private Element __I32_4;
91    private Element __I64;
92    private Element __I64_2;
93    private Element __I64_4;
94    private Element __I8;
95    private Element __I8_2;
96    private Element __I8_4;
97    private Element __U16;
98    private Element __U16_2;
99    private Element __U16_4;
100    private Element __U32;
101    private Element __U32_2;
102    private Element __U32_4;
103    private Element __U64;
104    private Element __U64_2;
105    private Element __U64_4;
106    private Element __U8;
107    private Element __U8_2;
108    private Element __U8_4;
109    private RenderScript mRSLocal;
110    // To obtain the result, invoke get(), which blocks
111    // until the asynchronously-launched operation has completed.
112    public static class resultArray7_bool {
113        public boolean[] get() {
114            if (!mGotResult) {
115                byte[] outArray = new byte[7];
116                mOut.copyTo(outArray);
117                boolean[] result = new boolean[7];
118                for (int Idx = 0; Idx < 7; ++Idx) {
119                    result[Idx] = outArray[Idx] != 0;
120                }
121
122                mResult = result;
123                mOut.destroy();
124                mOut = null;  // make Java object eligible for garbage collection
125                if (mTempIns != null) {
126                    for (Allocation tempIn : mTempIns) {
127                        tempIn.destroy();
128                    }
129
130                    mTempIns = null;  // make Java objects eligible for garbage collection
131                }
132
133                mGotResult = true;
134            }
135
136            return mResult;
137        }
138
139        private  resultArray7_bool(Allocation out) {
140            mTempIns = null;
141            mOut = out;
142            mGotResult = false;
143        }
144
145        private Allocation[] mTempIns;
146        private Allocation mOut;
147        private boolean mGotResult;
148        private boolean[] mResult;
149    }
150
151    // To obtain the result, invoke get(), which blocks
152    // until the asynchronously-launched operation has completed.
153    public static class resultArray7_char {
154        public byte[] get() {
155            if (!mGotResult) {
156                byte[] outArray = new byte[7];
157                mOut.copyTo(outArray);
158                mResult = outArray;
159                mOut.destroy();
160                mOut = null;  // make Java object eligible for garbage collection
161                if (mTempIns != null) {
162                    for (Allocation tempIn : mTempIns) {
163                        tempIn.destroy();
164                    }
165
166                    mTempIns = null;  // make Java objects eligible for garbage collection
167                }
168
169                mGotResult = true;
170            }
171
172            return mResult;
173        }
174
175        private  resultArray7_char(Allocation out) {
176            mTempIns = null;
177            mOut = out;
178            mGotResult = false;
179        }
180
181        private Allocation[] mTempIns;
182        private Allocation mOut;
183        private boolean mGotResult;
184        private byte[] mResult;
185    }
186
187    // To obtain the result, invoke get(), which blocks
188    // until the asynchronously-launched operation has completed.
189    public static class resultArray7_char2 {
190        public Byte2[] get() {
191            if (!mGotResult) {
192                byte[] outArray = new byte[14];
193                mOut.copyTo(outArray);
194                Byte2[] result = new Byte2[7];
195                for (int Idx = 0; Idx < 7; ++Idx) {
196                    result[Idx] = new Byte2(outArray[2*Idx+0], outArray[2*Idx+1]);
197                }
198
199                mResult = result;
200                mOut.destroy();
201                mOut = null;  // make Java object eligible for garbage collection
202                if (mTempIns != null) {
203                    for (Allocation tempIn : mTempIns) {
204                        tempIn.destroy();
205                    }
206
207                    mTempIns = null;  // make Java objects eligible for garbage collection
208                }
209
210                mGotResult = true;
211            }
212
213            return mResult;
214        }
215
216        private  resultArray7_char2(Allocation out) {
217            mTempIns = null;
218            mOut = out;
219            mGotResult = false;
220        }
221
222        private Allocation[] mTempIns;
223        private Allocation mOut;
224        private boolean mGotResult;
225        private Byte2[] mResult;
226    }
227
228    // To obtain the result, invoke get(), which blocks
229    // until the asynchronously-launched operation has completed.
230    public static class resultArray7_char4 {
231        public Byte4[] get() {
232            if (!mGotResult) {
233                byte[] outArray = new byte[28];
234                mOut.copyTo(outArray);
235                Byte4[] result = new Byte4[7];
236                for (int Idx = 0; Idx < 7; ++Idx) {
237                    result[Idx] = new Byte4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
238                }
239
240                mResult = result;
241                mOut.destroy();
242                mOut = null;  // make Java object eligible for garbage collection
243                if (mTempIns != null) {
244                    for (Allocation tempIn : mTempIns) {
245                        tempIn.destroy();
246                    }
247
248                    mTempIns = null;  // make Java objects eligible for garbage collection
249                }
250
251                mGotResult = true;
252            }
253
254            return mResult;
255        }
256
257        private  resultArray7_char4(Allocation out) {
258            mTempIns = null;
259            mOut = out;
260            mGotResult = false;
261        }
262
263        private Allocation[] mTempIns;
264        private Allocation mOut;
265        private boolean mGotResult;
266        private Byte4[] mResult;
267    }
268
269    // To obtain the result, invoke get(), which blocks
270    // until the asynchronously-launched operation has completed.
271    public static class resultArray7_double {
272        public double[] get() {
273            if (!mGotResult) {
274                double[] outArray = new double[7];
275                mOut.copyTo(outArray);
276                mResult = outArray;
277                mOut.destroy();
278                mOut = null;  // make Java object eligible for garbage collection
279                if (mTempIns != null) {
280                    for (Allocation tempIn : mTempIns) {
281                        tempIn.destroy();
282                    }
283
284                    mTempIns = null;  // make Java objects eligible for garbage collection
285                }
286
287                mGotResult = true;
288            }
289
290            return mResult;
291        }
292
293        private  resultArray7_double(Allocation out) {
294            mTempIns = null;
295            mOut = out;
296            mGotResult = false;
297        }
298
299        private Allocation[] mTempIns;
300        private Allocation mOut;
301        private boolean mGotResult;
302        private double[] mResult;
303    }
304
305    // To obtain the result, invoke get(), which blocks
306    // until the asynchronously-launched operation has completed.
307    public static class resultArray7_double2 {
308        public Double2[] get() {
309            if (!mGotResult) {
310                double[] outArray = new double[14];
311                mOut.copyTo(outArray);
312                Double2[] result = new Double2[7];
313                for (int Idx = 0; Idx < 7; ++Idx) {
314                    result[Idx] = new Double2(outArray[2*Idx+0], outArray[2*Idx+1]);
315                }
316
317                mResult = result;
318                mOut.destroy();
319                mOut = null;  // make Java object eligible for garbage collection
320                if (mTempIns != null) {
321                    for (Allocation tempIn : mTempIns) {
322                        tempIn.destroy();
323                    }
324
325                    mTempIns = null;  // make Java objects eligible for garbage collection
326                }
327
328                mGotResult = true;
329            }
330
331            return mResult;
332        }
333
334        private  resultArray7_double2(Allocation out) {
335            mTempIns = null;
336            mOut = out;
337            mGotResult = false;
338        }
339
340        private Allocation[] mTempIns;
341        private Allocation mOut;
342        private boolean mGotResult;
343        private Double2[] mResult;
344    }
345
346    // To obtain the result, invoke get(), which blocks
347    // until the asynchronously-launched operation has completed.
348    public static class resultArray7_double4 {
349        public Double4[] get() {
350            if (!mGotResult) {
351                double[] outArray = new double[28];
352                mOut.copyTo(outArray);
353                Double4[] result = new Double4[7];
354                for (int Idx = 0; Idx < 7; ++Idx) {
355                    result[Idx] = new Double4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
356                }
357
358                mResult = result;
359                mOut.destroy();
360                mOut = null;  // make Java object eligible for garbage collection
361                if (mTempIns != null) {
362                    for (Allocation tempIn : mTempIns) {
363                        tempIn.destroy();
364                    }
365
366                    mTempIns = null;  // make Java objects eligible for garbage collection
367                }
368
369                mGotResult = true;
370            }
371
372            return mResult;
373        }
374
375        private  resultArray7_double4(Allocation out) {
376            mTempIns = null;
377            mOut = out;
378            mGotResult = false;
379        }
380
381        private Allocation[] mTempIns;
382        private Allocation mOut;
383        private boolean mGotResult;
384        private Double4[] mResult;
385    }
386
387    // To obtain the result, invoke get(), which blocks
388    // until the asynchronously-launched operation has completed.
389    public static class resultArray7_float {
390        public float[] get() {
391            if (!mGotResult) {
392                float[] outArray = new float[7];
393                mOut.copyTo(outArray);
394                mResult = outArray;
395                mOut.destroy();
396                mOut = null;  // make Java object eligible for garbage collection
397                if (mTempIns != null) {
398                    for (Allocation tempIn : mTempIns) {
399                        tempIn.destroy();
400                    }
401
402                    mTempIns = null;  // make Java objects eligible for garbage collection
403                }
404
405                mGotResult = true;
406            }
407
408            return mResult;
409        }
410
411        private  resultArray7_float(Allocation out) {
412            mTempIns = null;
413            mOut = out;
414            mGotResult = false;
415        }
416
417        private Allocation[] mTempIns;
418        private Allocation mOut;
419        private boolean mGotResult;
420        private float[] mResult;
421    }
422
423    // To obtain the result, invoke get(), which blocks
424    // until the asynchronously-launched operation has completed.
425    public static class resultArray7_float2 {
426        public Float2[] get() {
427            if (!mGotResult) {
428                float[] outArray = new float[14];
429                mOut.copyTo(outArray);
430                Float2[] result = new Float2[7];
431                for (int Idx = 0; Idx < 7; ++Idx) {
432                    result[Idx] = new Float2(outArray[2*Idx+0], outArray[2*Idx+1]);
433                }
434
435                mResult = result;
436                mOut.destroy();
437                mOut = null;  // make Java object eligible for garbage collection
438                if (mTempIns != null) {
439                    for (Allocation tempIn : mTempIns) {
440                        tempIn.destroy();
441                    }
442
443                    mTempIns = null;  // make Java objects eligible for garbage collection
444                }
445
446                mGotResult = true;
447            }
448
449            return mResult;
450        }
451
452        private  resultArray7_float2(Allocation out) {
453            mTempIns = null;
454            mOut = out;
455            mGotResult = false;
456        }
457
458        private Allocation[] mTempIns;
459        private Allocation mOut;
460        private boolean mGotResult;
461        private Float2[] mResult;
462    }
463
464    // To obtain the result, invoke get(), which blocks
465    // until the asynchronously-launched operation has completed.
466    public static class resultArray7_float4 {
467        public Float4[] get() {
468            if (!mGotResult) {
469                float[] outArray = new float[28];
470                mOut.copyTo(outArray);
471                Float4[] result = new Float4[7];
472                for (int Idx = 0; Idx < 7; ++Idx) {
473                    result[Idx] = new Float4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
474                }
475
476                mResult = result;
477                mOut.destroy();
478                mOut = null;  // make Java object eligible for garbage collection
479                if (mTempIns != null) {
480                    for (Allocation tempIn : mTempIns) {
481                        tempIn.destroy();
482                    }
483
484                    mTempIns = null;  // make Java objects eligible for garbage collection
485                }
486
487                mGotResult = true;
488            }
489
490            return mResult;
491        }
492
493        private  resultArray7_float4(Allocation out) {
494            mTempIns = null;
495            mOut = out;
496            mGotResult = false;
497        }
498
499        private Allocation[] mTempIns;
500        private Allocation mOut;
501        private boolean mGotResult;
502        private Float4[] mResult;
503    }
504
505    // To obtain the result, invoke get(), which blocks
506    // until the asynchronously-launched operation has completed.
507    public static class resultArray7_half {
508        public short[] get() {
509            if (!mGotResult) {
510                short[] outArray = new short[7];
511                mOut.copyTo(outArray);
512                mResult = outArray;
513                mOut.destroy();
514                mOut = null;  // make Java object eligible for garbage collection
515                if (mTempIns != null) {
516                    for (Allocation tempIn : mTempIns) {
517                        tempIn.destroy();
518                    }
519
520                    mTempIns = null;  // make Java objects eligible for garbage collection
521                }
522
523                mGotResult = true;
524            }
525
526            return mResult;
527        }
528
529        private  resultArray7_half(Allocation out) {
530            mTempIns = null;
531            mOut = out;
532            mGotResult = false;
533        }
534
535        private Allocation[] mTempIns;
536        private Allocation mOut;
537        private boolean mGotResult;
538        private short[] mResult;
539    }
540
541    // To obtain the result, invoke get(), which blocks
542    // until the asynchronously-launched operation has completed.
543    public static class resultArray7_half2 {
544        public Short2[] get() {
545            if (!mGotResult) {
546                short[] outArray = new short[14];
547                mOut.copyTo(outArray);
548                Short2[] result = new Short2[7];
549                for (int Idx = 0; Idx < 7; ++Idx) {
550                    result[Idx] = new Short2(outArray[2*Idx+0], outArray[2*Idx+1]);
551                }
552
553                mResult = result;
554                mOut.destroy();
555                mOut = null;  // make Java object eligible for garbage collection
556                if (mTempIns != null) {
557                    for (Allocation tempIn : mTempIns) {
558                        tempIn.destroy();
559                    }
560
561                    mTempIns = null;  // make Java objects eligible for garbage collection
562                }
563
564                mGotResult = true;
565            }
566
567            return mResult;
568        }
569
570        private  resultArray7_half2(Allocation out) {
571            mTempIns = null;
572            mOut = out;
573            mGotResult = false;
574        }
575
576        private Allocation[] mTempIns;
577        private Allocation mOut;
578        private boolean mGotResult;
579        private Short2[] mResult;
580    }
581
582    // To obtain the result, invoke get(), which blocks
583    // until the asynchronously-launched operation has completed.
584    public static class resultArray7_half4 {
585        public Short4[] get() {
586            if (!mGotResult) {
587                short[] outArray = new short[28];
588                mOut.copyTo(outArray);
589                Short4[] result = new Short4[7];
590                for (int Idx = 0; Idx < 7; ++Idx) {
591                    result[Idx] = new Short4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
592                }
593
594                mResult = result;
595                mOut.destroy();
596                mOut = null;  // make Java object eligible for garbage collection
597                if (mTempIns != null) {
598                    for (Allocation tempIn : mTempIns) {
599                        tempIn.destroy();
600                    }
601
602                    mTempIns = null;  // make Java objects eligible for garbage collection
603                }
604
605                mGotResult = true;
606            }
607
608            return mResult;
609        }
610
611        private  resultArray7_half4(Allocation out) {
612            mTempIns = null;
613            mOut = out;
614            mGotResult = false;
615        }
616
617        private Allocation[] mTempIns;
618        private Allocation mOut;
619        private boolean mGotResult;
620        private Short4[] mResult;
621    }
622
623    // To obtain the result, invoke get(), which blocks
624    // until the asynchronously-launched operation has completed.
625    public static class resultArray7_int {
626        public int[] get() {
627            if (!mGotResult) {
628                int[] outArray = new int[7];
629                mOut.copyTo(outArray);
630                mResult = outArray;
631                mOut.destroy();
632                mOut = null;  // make Java object eligible for garbage collection
633                if (mTempIns != null) {
634                    for (Allocation tempIn : mTempIns) {
635                        tempIn.destroy();
636                    }
637
638                    mTempIns = null;  // make Java objects eligible for garbage collection
639                }
640
641                mGotResult = true;
642            }
643
644            return mResult;
645        }
646
647        private  resultArray7_int(Allocation out) {
648            mTempIns = null;
649            mOut = out;
650            mGotResult = false;
651        }
652
653        private Allocation[] mTempIns;
654        private Allocation mOut;
655        private boolean mGotResult;
656        private int[] mResult;
657    }
658
659    // To obtain the result, invoke get(), which blocks
660    // until the asynchronously-launched operation has completed.
661    public static class resultArray7_int2 {
662        public Int2[] get() {
663            if (!mGotResult) {
664                int[] outArray = new int[14];
665                mOut.copyTo(outArray);
666                Int2[] result = new Int2[7];
667                for (int Idx = 0; Idx < 7; ++Idx) {
668                    result[Idx] = new Int2(outArray[2*Idx+0], outArray[2*Idx+1]);
669                }
670
671                mResult = result;
672                mOut.destroy();
673                mOut = null;  // make Java object eligible for garbage collection
674                if (mTempIns != null) {
675                    for (Allocation tempIn : mTempIns) {
676                        tempIn.destroy();
677                    }
678
679                    mTempIns = null;  // make Java objects eligible for garbage collection
680                }
681
682                mGotResult = true;
683            }
684
685            return mResult;
686        }
687
688        private  resultArray7_int2(Allocation out) {
689            mTempIns = null;
690            mOut = out;
691            mGotResult = false;
692        }
693
694        private Allocation[] mTempIns;
695        private Allocation mOut;
696        private boolean mGotResult;
697        private Int2[] mResult;
698    }
699
700    // To obtain the result, invoke get(), which blocks
701    // until the asynchronously-launched operation has completed.
702    public static class resultArray7_int4 {
703        public Int4[] get() {
704            if (!mGotResult) {
705                int[] outArray = new int[28];
706                mOut.copyTo(outArray);
707                Int4[] result = new Int4[7];
708                for (int Idx = 0; Idx < 7; ++Idx) {
709                    result[Idx] = new Int4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
710                }
711
712                mResult = result;
713                mOut.destroy();
714                mOut = null;  // make Java object eligible for garbage collection
715                if (mTempIns != null) {
716                    for (Allocation tempIn : mTempIns) {
717                        tempIn.destroy();
718                    }
719
720                    mTempIns = null;  // make Java objects eligible for garbage collection
721                }
722
723                mGotResult = true;
724            }
725
726            return mResult;
727        }
728
729        private  resultArray7_int4(Allocation out) {
730            mTempIns = null;
731            mOut = out;
732            mGotResult = false;
733        }
734
735        private Allocation[] mTempIns;
736        private Allocation mOut;
737        private boolean mGotResult;
738        private Int4[] mResult;
739    }
740
741    // To obtain the result, invoke get(), which blocks
742    // until the asynchronously-launched operation has completed.
743    public static class resultArray7_long {
744        public long[] get() {
745            if (!mGotResult) {
746                long[] outArray = new long[7];
747                mOut.copyTo(outArray);
748                mResult = outArray;
749                mOut.destroy();
750                mOut = null;  // make Java object eligible for garbage collection
751                if (mTempIns != null) {
752                    for (Allocation tempIn : mTempIns) {
753                        tempIn.destroy();
754                    }
755
756                    mTempIns = null;  // make Java objects eligible for garbage collection
757                }
758
759                mGotResult = true;
760            }
761
762            return mResult;
763        }
764
765        private  resultArray7_long(Allocation out) {
766            mTempIns = null;
767            mOut = out;
768            mGotResult = false;
769        }
770
771        private Allocation[] mTempIns;
772        private Allocation mOut;
773        private boolean mGotResult;
774        private long[] mResult;
775    }
776
777    // To obtain the result, invoke get(), which blocks
778    // until the asynchronously-launched operation has completed.
779    public static class resultArray7_long2 {
780        public Long2[] get() {
781            if (!mGotResult) {
782                long[] outArray = new long[14];
783                mOut.copyTo(outArray);
784                Long2[] result = new Long2[7];
785                for (int Idx = 0; Idx < 7; ++Idx) {
786                    result[Idx] = new Long2(outArray[2*Idx+0], outArray[2*Idx+1]);
787                }
788
789                mResult = result;
790                mOut.destroy();
791                mOut = null;  // make Java object eligible for garbage collection
792                if (mTempIns != null) {
793                    for (Allocation tempIn : mTempIns) {
794                        tempIn.destroy();
795                    }
796
797                    mTempIns = null;  // make Java objects eligible for garbage collection
798                }
799
800                mGotResult = true;
801            }
802
803            return mResult;
804        }
805
806        private  resultArray7_long2(Allocation out) {
807            mTempIns = null;
808            mOut = out;
809            mGotResult = false;
810        }
811
812        private Allocation[] mTempIns;
813        private Allocation mOut;
814        private boolean mGotResult;
815        private Long2[] mResult;
816    }
817
818    // To obtain the result, invoke get(), which blocks
819    // until the asynchronously-launched operation has completed.
820    public static class resultArray7_long4 {
821        public Long4[] get() {
822            if (!mGotResult) {
823                long[] outArray = new long[28];
824                mOut.copyTo(outArray);
825                Long4[] result = new Long4[7];
826                for (int Idx = 0; Idx < 7; ++Idx) {
827                    result[Idx] = new Long4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
828                }
829
830                mResult = result;
831                mOut.destroy();
832                mOut = null;  // make Java object eligible for garbage collection
833                if (mTempIns != null) {
834                    for (Allocation tempIn : mTempIns) {
835                        tempIn.destroy();
836                    }
837
838                    mTempIns = null;  // make Java objects eligible for garbage collection
839                }
840
841                mGotResult = true;
842            }
843
844            return mResult;
845        }
846
847        private  resultArray7_long4(Allocation out) {
848            mTempIns = null;
849            mOut = out;
850            mGotResult = false;
851        }
852
853        private Allocation[] mTempIns;
854        private Allocation mOut;
855        private boolean mGotResult;
856        private Long4[] mResult;
857    }
858
859    // To obtain the result, invoke get(), which blocks
860    // until the asynchronously-launched operation has completed.
861    public static class resultArray7_short {
862        public short[] get() {
863            if (!mGotResult) {
864                short[] outArray = new short[7];
865                mOut.copyTo(outArray);
866                mResult = outArray;
867                mOut.destroy();
868                mOut = null;  // make Java object eligible for garbage collection
869                if (mTempIns != null) {
870                    for (Allocation tempIn : mTempIns) {
871                        tempIn.destroy();
872                    }
873
874                    mTempIns = null;  // make Java objects eligible for garbage collection
875                }
876
877                mGotResult = true;
878            }
879
880            return mResult;
881        }
882
883        private  resultArray7_short(Allocation out) {
884            mTempIns = null;
885            mOut = out;
886            mGotResult = false;
887        }
888
889        private Allocation[] mTempIns;
890        private Allocation mOut;
891        private boolean mGotResult;
892        private short[] mResult;
893    }
894
895    // To obtain the result, invoke get(), which blocks
896    // until the asynchronously-launched operation has completed.
897    public static class resultArray7_short2 {
898        public Short2[] get() {
899            if (!mGotResult) {
900                short[] outArray = new short[14];
901                mOut.copyTo(outArray);
902                Short2[] result = new Short2[7];
903                for (int Idx = 0; Idx < 7; ++Idx) {
904                    result[Idx] = new Short2(outArray[2*Idx+0], outArray[2*Idx+1]);
905                }
906
907                mResult = result;
908                mOut.destroy();
909                mOut = null;  // make Java object eligible for garbage collection
910                if (mTempIns != null) {
911                    for (Allocation tempIn : mTempIns) {
912                        tempIn.destroy();
913                    }
914
915                    mTempIns = null;  // make Java objects eligible for garbage collection
916                }
917
918                mGotResult = true;
919            }
920
921            return mResult;
922        }
923
924        private  resultArray7_short2(Allocation out) {
925            mTempIns = null;
926            mOut = out;
927            mGotResult = false;
928        }
929
930        private Allocation[] mTempIns;
931        private Allocation mOut;
932        private boolean mGotResult;
933        private Short2[] mResult;
934    }
935
936    // To obtain the result, invoke get(), which blocks
937    // until the asynchronously-launched operation has completed.
938    public static class resultArray7_short4 {
939        public Short4[] get() {
940            if (!mGotResult) {
941                short[] outArray = new short[28];
942                mOut.copyTo(outArray);
943                Short4[] result = new Short4[7];
944                for (int Idx = 0; Idx < 7; ++Idx) {
945                    result[Idx] = new Short4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
946                }
947
948                mResult = result;
949                mOut.destroy();
950                mOut = null;  // make Java object eligible for garbage collection
951                if (mTempIns != null) {
952                    for (Allocation tempIn : mTempIns) {
953                        tempIn.destroy();
954                    }
955
956                    mTempIns = null;  // make Java objects eligible for garbage collection
957                }
958
959                mGotResult = true;
960            }
961
962            return mResult;
963        }
964
965        private  resultArray7_short4(Allocation out) {
966            mTempIns = null;
967            mOut = out;
968            mGotResult = false;
969        }
970
971        private Allocation[] mTempIns;
972        private Allocation mOut;
973        private boolean mGotResult;
974        private Short4[] mResult;
975    }
976
977    // To obtain the result, invoke get(), which blocks
978    // until the asynchronously-launched operation has completed.
979    public static class resultArray7_uchar {
980        public short[] get() {
981            if (!mGotResult) {
982                byte[] outArray = new byte[7];
983                mOut.copyTo(outArray);
984                short[] result = new short[7];
985                for (int Idx = 0; Idx < 7; ++Idx) {
986                    result[Idx] = ((short) ((outArray[Idx]) & (short) 0xff));
987                }
988
989                mResult = result;
990                mOut.destroy();
991                mOut = null;  // make Java object eligible for garbage collection
992                if (mTempIns != null) {
993                    for (Allocation tempIn : mTempIns) {
994                        tempIn.destroy();
995                    }
996
997                    mTempIns = null;  // make Java objects eligible for garbage collection
998                }
999
1000                mGotResult = true;
1001            }
1002
1003            return mResult;
1004        }
1005
1006        private  resultArray7_uchar(Allocation out) {
1007            mTempIns = null;
1008            mOut = out;
1009            mGotResult = false;
1010        }
1011
1012        private Allocation[] mTempIns;
1013        private Allocation mOut;
1014        private boolean mGotResult;
1015        private short[] mResult;
1016    }
1017
1018    // To obtain the result, invoke get(), which blocks
1019    // until the asynchronously-launched operation has completed.
1020    public static class resultArray7_uchar2 {
1021        public Short2[] get() {
1022            if (!mGotResult) {
1023                byte[] outArray = new byte[14];
1024                mOut.copyTo(outArray);
1025                Short2[] result = new Short2[7];
1026                for (int Idx = 0; Idx < 7; ++Idx) {
1027                    result[Idx] = new Short2(((short) ((outArray[2*Idx+0]) & (short) 0xff)), ((short) ((outArray[2*Idx+1]) & (short) 0xff)));
1028                }
1029
1030                mResult = result;
1031                mOut.destroy();
1032                mOut = null;  // make Java object eligible for garbage collection
1033                if (mTempIns != null) {
1034                    for (Allocation tempIn : mTempIns) {
1035                        tempIn.destroy();
1036                    }
1037
1038                    mTempIns = null;  // make Java objects eligible for garbage collection
1039                }
1040
1041                mGotResult = true;
1042            }
1043
1044            return mResult;
1045        }
1046
1047        private  resultArray7_uchar2(Allocation out) {
1048            mTempIns = null;
1049            mOut = out;
1050            mGotResult = false;
1051        }
1052
1053        private Allocation[] mTempIns;
1054        private Allocation mOut;
1055        private boolean mGotResult;
1056        private Short2[] mResult;
1057    }
1058
1059    // To obtain the result, invoke get(), which blocks
1060    // until the asynchronously-launched operation has completed.
1061    public static class resultArray7_uchar4 {
1062        public Short4[] get() {
1063            if (!mGotResult) {
1064                byte[] outArray = new byte[28];
1065                mOut.copyTo(outArray);
1066                Short4[] result = new Short4[7];
1067                for (int Idx = 0; Idx < 7; ++Idx) {
1068                    result[Idx] = new Short4(((short) ((outArray[4*Idx+0]) & (short) 0xff)), ((short) ((outArray[4*Idx+1]) & (short) 0xff)), ((short) ((outArray[4*Idx+2]) & (short) 0xff)), ((short) ((outArray[4*Idx+3]) & (short) 0xff)));
1069                }
1070
1071                mResult = result;
1072                mOut.destroy();
1073                mOut = null;  // make Java object eligible for garbage collection
1074                if (mTempIns != null) {
1075                    for (Allocation tempIn : mTempIns) {
1076                        tempIn.destroy();
1077                    }
1078
1079                    mTempIns = null;  // make Java objects eligible for garbage collection
1080                }
1081
1082                mGotResult = true;
1083            }
1084
1085            return mResult;
1086        }
1087
1088        private  resultArray7_uchar4(Allocation out) {
1089            mTempIns = null;
1090            mOut = out;
1091            mGotResult = false;
1092        }
1093
1094        private Allocation[] mTempIns;
1095        private Allocation mOut;
1096        private boolean mGotResult;
1097        private Short4[] mResult;
1098    }
1099
1100    // To obtain the result, invoke get(), which blocks
1101    // until the asynchronously-launched operation has completed.
1102    public static class resultArray7_uint {
1103        public long[] get() {
1104            if (!mGotResult) {
1105                int[] outArray = new int[7];
1106                mOut.copyTo(outArray);
1107                long[] result = new long[7];
1108                for (int Idx = 0; Idx < 7; ++Idx) {
1109                    result[Idx] = ((long) ((outArray[Idx]) & 0xffffffffL));
1110                }
1111
1112                mResult = result;
1113                mOut.destroy();
1114                mOut = null;  // make Java object eligible for garbage collection
1115                if (mTempIns != null) {
1116                    for (Allocation tempIn : mTempIns) {
1117                        tempIn.destroy();
1118                    }
1119
1120                    mTempIns = null;  // make Java objects eligible for garbage collection
1121                }
1122
1123                mGotResult = true;
1124            }
1125
1126            return mResult;
1127        }
1128
1129        private  resultArray7_uint(Allocation out) {
1130            mTempIns = null;
1131            mOut = out;
1132            mGotResult = false;
1133        }
1134
1135        private Allocation[] mTempIns;
1136        private Allocation mOut;
1137        private boolean mGotResult;
1138        private long[] mResult;
1139    }
1140
1141    // To obtain the result, invoke get(), which blocks
1142    // until the asynchronously-launched operation has completed.
1143    public static class resultArray7_uint2 {
1144        public Long2[] get() {
1145            if (!mGotResult) {
1146                int[] outArray = new int[14];
1147                mOut.copyTo(outArray);
1148                Long2[] result = new Long2[7];
1149                for (int Idx = 0; Idx < 7; ++Idx) {
1150                    result[Idx] = new Long2(((long) ((outArray[2*Idx+0]) & 0xffffffffL)), ((long) ((outArray[2*Idx+1]) & 0xffffffffL)));
1151                }
1152
1153                mResult = result;
1154                mOut.destroy();
1155                mOut = null;  // make Java object eligible for garbage collection
1156                if (mTempIns != null) {
1157                    for (Allocation tempIn : mTempIns) {
1158                        tempIn.destroy();
1159                    }
1160
1161                    mTempIns = null;  // make Java objects eligible for garbage collection
1162                }
1163
1164                mGotResult = true;
1165            }
1166
1167            return mResult;
1168        }
1169
1170        private  resultArray7_uint2(Allocation out) {
1171            mTempIns = null;
1172            mOut = out;
1173            mGotResult = false;
1174        }
1175
1176        private Allocation[] mTempIns;
1177        private Allocation mOut;
1178        private boolean mGotResult;
1179        private Long2[] mResult;
1180    }
1181
1182    // To obtain the result, invoke get(), which blocks
1183    // until the asynchronously-launched operation has completed.
1184    public static class resultArray7_uint4 {
1185        public Long4[] get() {
1186            if (!mGotResult) {
1187                int[] outArray = new int[28];
1188                mOut.copyTo(outArray);
1189                Long4[] result = new Long4[7];
1190                for (int Idx = 0; Idx < 7; ++Idx) {
1191                    result[Idx] = new Long4(((long) ((outArray[4*Idx+0]) & 0xffffffffL)), ((long) ((outArray[4*Idx+1]) & 0xffffffffL)), ((long) ((outArray[4*Idx+2]) & 0xffffffffL)), ((long) ((outArray[4*Idx+3]) & 0xffffffffL)));
1192                }
1193
1194                mResult = result;
1195                mOut.destroy();
1196                mOut = null;  // make Java object eligible for garbage collection
1197                if (mTempIns != null) {
1198                    for (Allocation tempIn : mTempIns) {
1199                        tempIn.destroy();
1200                    }
1201
1202                    mTempIns = null;  // make Java objects eligible for garbage collection
1203                }
1204
1205                mGotResult = true;
1206            }
1207
1208            return mResult;
1209        }
1210
1211        private  resultArray7_uint4(Allocation out) {
1212            mTempIns = null;
1213            mOut = out;
1214            mGotResult = false;
1215        }
1216
1217        private Allocation[] mTempIns;
1218        private Allocation mOut;
1219        private boolean mGotResult;
1220        private Long4[] mResult;
1221    }
1222
1223    // To obtain the result, invoke get(), which blocks
1224    // until the asynchronously-launched operation has completed.
1225    public static class resultArray7_ulong {
1226        public long[] get() {
1227            if (!mGotResult) {
1228                long[] outArray = new long[7];
1229                mOut.copyTo(outArray);
1230                for (int Idx = 0; Idx < 7; ++Idx) {
1231                    if (outArray[Idx] < 0)
1232                        throw new RSRuntimeException("Result is not representible in Java");
1233                }
1234
1235                mResult = outArray;
1236                mOut.destroy();
1237                mOut = null;  // make Java object eligible for garbage collection
1238                if (mTempIns != null) {
1239                    for (Allocation tempIn : mTempIns) {
1240                        tempIn.destroy();
1241                    }
1242
1243                    mTempIns = null;  // make Java objects eligible for garbage collection
1244                }
1245
1246                mGotResult = true;
1247            }
1248
1249            return mResult;
1250        }
1251
1252        private  resultArray7_ulong(Allocation out) {
1253            mTempIns = null;
1254            mOut = out;
1255            mGotResult = false;
1256        }
1257
1258        private Allocation[] mTempIns;
1259        private Allocation mOut;
1260        private boolean mGotResult;
1261        private long[] mResult;
1262    }
1263
1264    // To obtain the result, invoke get(), which blocks
1265    // until the asynchronously-launched operation has completed.
1266    public static class resultArray7_ulong2 {
1267        public Long2[] get() {
1268            if (!mGotResult) {
1269                long[] outArray = new long[14];
1270                mOut.copyTo(outArray);
1271                for (int Idx = 0; Idx < 14; ++Idx) {
1272                    if (outArray[Idx] < 0)
1273                        throw new RSRuntimeException("Result is not representible in Java");
1274                }
1275
1276                Long2[] result = new Long2[7];
1277                for (int Idx = 0; Idx < 7; ++Idx) {
1278                    result[Idx] = new Long2(outArray[2*Idx+0], outArray[2*Idx+1]);
1279                }
1280
1281                mResult = result;
1282                mOut.destroy();
1283                mOut = null;  // make Java object eligible for garbage collection
1284                if (mTempIns != null) {
1285                    for (Allocation tempIn : mTempIns) {
1286                        tempIn.destroy();
1287                    }
1288
1289                    mTempIns = null;  // make Java objects eligible for garbage collection
1290                }
1291
1292                mGotResult = true;
1293            }
1294
1295            return mResult;
1296        }
1297
1298        private  resultArray7_ulong2(Allocation out) {
1299            mTempIns = null;
1300            mOut = out;
1301            mGotResult = false;
1302        }
1303
1304        private Allocation[] mTempIns;
1305        private Allocation mOut;
1306        private boolean mGotResult;
1307        private Long2[] mResult;
1308    }
1309
1310    // To obtain the result, invoke get(), which blocks
1311    // until the asynchronously-launched operation has completed.
1312    public static class resultArray7_ulong4 {
1313        public Long4[] get() {
1314            if (!mGotResult) {
1315                long[] outArray = new long[28];
1316                mOut.copyTo(outArray);
1317                for (int Idx = 0; Idx < 28; ++Idx) {
1318                    if (outArray[Idx] < 0)
1319                        throw new RSRuntimeException("Result is not representible in Java");
1320                }
1321
1322                Long4[] result = new Long4[7];
1323                for (int Idx = 0; Idx < 7; ++Idx) {
1324                    result[Idx] = new Long4(outArray[4*Idx+0], outArray[4*Idx+1], outArray[4*Idx+2], outArray[4*Idx+3]);
1325                }
1326
1327                mResult = result;
1328                mOut.destroy();
1329                mOut = null;  // make Java object eligible for garbage collection
1330                if (mTempIns != null) {
1331                    for (Allocation tempIn : mTempIns) {
1332                        tempIn.destroy();
1333                    }
1334
1335                    mTempIns = null;  // make Java objects eligible for garbage collection
1336                }
1337
1338                mGotResult = true;
1339            }
1340
1341            return mResult;
1342        }
1343
1344        private  resultArray7_ulong4(Allocation out) {
1345            mTempIns = null;
1346            mOut = out;
1347            mGotResult = false;
1348        }
1349
1350        private Allocation[] mTempIns;
1351        private Allocation mOut;
1352        private boolean mGotResult;
1353        private Long4[] mResult;
1354    }
1355
1356    // To obtain the result, invoke get(), which blocks
1357    // until the asynchronously-launched operation has completed.
1358    public static class resultArray7_ushort {
1359        public int[] get() {
1360            if (!mGotResult) {
1361                short[] outArray = new short[7];
1362                mOut.copyTo(outArray);
1363                int[] result = new int[7];
1364                for (int Idx = 0; Idx < 7; ++Idx) {
1365                    result[Idx] = ((int) ((outArray[Idx]) & 0xffff));
1366                }
1367
1368                mResult = result;
1369                mOut.destroy();
1370                mOut = null;  // make Java object eligible for garbage collection
1371                if (mTempIns != null) {
1372                    for (Allocation tempIn : mTempIns) {
1373                        tempIn.destroy();
1374                    }
1375
1376                    mTempIns = null;  // make Java objects eligible for garbage collection
1377                }
1378
1379                mGotResult = true;
1380            }
1381
1382            return mResult;
1383        }
1384
1385        private  resultArray7_ushort(Allocation out) {
1386            mTempIns = null;
1387            mOut = out;
1388            mGotResult = false;
1389        }
1390
1391        private Allocation[] mTempIns;
1392        private Allocation mOut;
1393        private boolean mGotResult;
1394        private int[] mResult;
1395    }
1396
1397    // To obtain the result, invoke get(), which blocks
1398    // until the asynchronously-launched operation has completed.
1399    public static class resultArray7_ushort2 {
1400        public Int2[] get() {
1401            if (!mGotResult) {
1402                short[] outArray = new short[14];
1403                mOut.copyTo(outArray);
1404                Int2[] result = new Int2[7];
1405                for (int Idx = 0; Idx < 7; ++Idx) {
1406                    result[Idx] = new Int2(((int) ((outArray[2*Idx+0]) & 0xffff)), ((int) ((outArray[2*Idx+1]) & 0xffff)));
1407                }
1408
1409                mResult = result;
1410                mOut.destroy();
1411                mOut = null;  // make Java object eligible for garbage collection
1412                if (mTempIns != null) {
1413                    for (Allocation tempIn : mTempIns) {
1414                        tempIn.destroy();
1415                    }
1416
1417                    mTempIns = null;  // make Java objects eligible for garbage collection
1418                }
1419
1420                mGotResult = true;
1421            }
1422
1423            return mResult;
1424        }
1425
1426        private  resultArray7_ushort2(Allocation out) {
1427            mTempIns = null;
1428            mOut = out;
1429            mGotResult = false;
1430        }
1431
1432        private Allocation[] mTempIns;
1433        private Allocation mOut;
1434        private boolean mGotResult;
1435        private Int2[] mResult;
1436    }
1437
1438    // To obtain the result, invoke get(), which blocks
1439    // until the asynchronously-launched operation has completed.
1440    public static class resultArray7_ushort4 {
1441        public Int4[] get() {
1442            if (!mGotResult) {
1443                short[] outArray = new short[28];
1444                mOut.copyTo(outArray);
1445                Int4[] result = new Int4[7];
1446                for (int Idx = 0; Idx < 7; ++Idx) {
1447                    result[Idx] = new Int4(((int) ((outArray[4*Idx+0]) & 0xffff)), ((int) ((outArray[4*Idx+1]) & 0xffff)), ((int) ((outArray[4*Idx+2]) & 0xffff)), ((int) ((outArray[4*Idx+3]) & 0xffff)));
1448                }
1449
1450                mResult = result;
1451                mOut.destroy();
1452                mOut = null;  // make Java object eligible for garbage collection
1453                if (mTempIns != null) {
1454                    for (Allocation tempIn : mTempIns) {
1455                        tempIn.destroy();
1456                    }
1457
1458                    mTempIns = null;  // make Java objects eligible for garbage collection
1459                }
1460
1461                mGotResult = true;
1462            }
1463
1464            return mResult;
1465        }
1466
1467        private  resultArray7_ushort4(Allocation out) {
1468            mTempIns = null;
1469            mOut = out;
1470            mGotResult = false;
1471        }
1472
1473        private Allocation[] mTempIns;
1474        private Allocation mOut;
1475        private boolean mGotResult;
1476        private Int4[] mResult;
1477    }
1478
1479    // To obtain the result, invoke get(), which blocks
1480    // until the asynchronously-launched operation has completed.
1481    public static class result_bool {
1482        public boolean get() {
1483            if (!mGotResult) {
1484                byte[] outArray = new byte[1];
1485                mOut.copyTo(outArray);
1486                mResult = outArray[0] != 0;
1487                mOut.destroy();
1488                mOut = null;  // make Java object eligible for garbage collection
1489                if (mTempIns != null) {
1490                    for (Allocation tempIn : mTempIns) {
1491                        tempIn.destroy();
1492                    }
1493
1494                    mTempIns = null;  // make Java objects eligible for garbage collection
1495                }
1496
1497                mGotResult = true;
1498            }
1499
1500            return mResult;
1501        }
1502
1503        private  result_bool(Allocation out) {
1504            mTempIns = null;
1505            mOut = out;
1506            mGotResult = false;
1507        }
1508
1509        private Allocation[] mTempIns;
1510        private Allocation mOut;
1511        private boolean mGotResult;
1512        private boolean mResult;
1513    }
1514
1515    // To obtain the result, invoke get(), which blocks
1516    // until the asynchronously-launched operation has completed.
1517    public static class result_char {
1518        public byte get() {
1519            if (!mGotResult) {
1520                byte[] outArray = new byte[1];
1521                mOut.copyTo(outArray);
1522                mResult = outArray[0];
1523                mOut.destroy();
1524                mOut = null;  // make Java object eligible for garbage collection
1525                if (mTempIns != null) {
1526                    for (Allocation tempIn : mTempIns) {
1527                        tempIn.destroy();
1528                    }
1529
1530                    mTempIns = null;  // make Java objects eligible for garbage collection
1531                }
1532
1533                mGotResult = true;
1534            }
1535
1536            return mResult;
1537        }
1538
1539        private  result_char(Allocation out) {
1540            mTempIns = null;
1541            mOut = out;
1542            mGotResult = false;
1543        }
1544
1545        private Allocation[] mTempIns;
1546        private Allocation mOut;
1547        private boolean mGotResult;
1548        private byte mResult;
1549    }
1550
1551    // To obtain the result, invoke get(), which blocks
1552    // until the asynchronously-launched operation has completed.
1553    public static class result_char2 {
1554        public Byte2 get() {
1555            if (!mGotResult) {
1556                byte[] outArray = new byte[2];
1557                mOut.copyTo(outArray);
1558                mResult = new Byte2(outArray[0], outArray[1]);
1559                mOut.destroy();
1560                mOut = null;  // make Java object eligible for garbage collection
1561                if (mTempIns != null) {
1562                    for (Allocation tempIn : mTempIns) {
1563                        tempIn.destroy();
1564                    }
1565
1566                    mTempIns = null;  // make Java objects eligible for garbage collection
1567                }
1568
1569                mGotResult = true;
1570            }
1571
1572            return mResult;
1573        }
1574
1575        private  result_char2(Allocation out) {
1576            mTempIns = null;
1577            mOut = out;
1578            mGotResult = false;
1579        }
1580
1581        private Allocation[] mTempIns;
1582        private Allocation mOut;
1583        private boolean mGotResult;
1584        private Byte2 mResult;
1585    }
1586
1587    // To obtain the result, invoke get(), which blocks
1588    // until the asynchronously-launched operation has completed.
1589    public static class result_char4 {
1590        public Byte4 get() {
1591            if (!mGotResult) {
1592                byte[] outArray = new byte[4];
1593                mOut.copyTo(outArray);
1594                mResult = new Byte4(outArray[0], outArray[1], outArray[2], outArray[3]);
1595                mOut.destroy();
1596                mOut = null;  // make Java object eligible for garbage collection
1597                if (mTempIns != null) {
1598                    for (Allocation tempIn : mTempIns) {
1599                        tempIn.destroy();
1600                    }
1601
1602                    mTempIns = null;  // make Java objects eligible for garbage collection
1603                }
1604
1605                mGotResult = true;
1606            }
1607
1608            return mResult;
1609        }
1610
1611        private  result_char4(Allocation out) {
1612            mTempIns = null;
1613            mOut = out;
1614            mGotResult = false;
1615        }
1616
1617        private Allocation[] mTempIns;
1618        private Allocation mOut;
1619        private boolean mGotResult;
1620        private Byte4 mResult;
1621    }
1622
1623    // To obtain the result, invoke get(), which blocks
1624    // until the asynchronously-launched operation has completed.
1625    public static class result_double {
1626        public double get() {
1627            if (!mGotResult) {
1628                double[] outArray = new double[1];
1629                mOut.copyTo(outArray);
1630                mResult = outArray[0];
1631                mOut.destroy();
1632                mOut = null;  // make Java object eligible for garbage collection
1633                if (mTempIns != null) {
1634                    for (Allocation tempIn : mTempIns) {
1635                        tempIn.destroy();
1636                    }
1637
1638                    mTempIns = null;  // make Java objects eligible for garbage collection
1639                }
1640
1641                mGotResult = true;
1642            }
1643
1644            return mResult;
1645        }
1646
1647        private  result_double(Allocation out) {
1648            mTempIns = null;
1649            mOut = out;
1650            mGotResult = false;
1651        }
1652
1653        private Allocation[] mTempIns;
1654        private Allocation mOut;
1655        private boolean mGotResult;
1656        private double mResult;
1657    }
1658
1659    // To obtain the result, invoke get(), which blocks
1660    // until the asynchronously-launched operation has completed.
1661    public static class result_double2 {
1662        public Double2 get() {
1663            if (!mGotResult) {
1664                double[] outArray = new double[2];
1665                mOut.copyTo(outArray);
1666                mResult = new Double2(outArray[0], outArray[1]);
1667                mOut.destroy();
1668                mOut = null;  // make Java object eligible for garbage collection
1669                if (mTempIns != null) {
1670                    for (Allocation tempIn : mTempIns) {
1671                        tempIn.destroy();
1672                    }
1673
1674                    mTempIns = null;  // make Java objects eligible for garbage collection
1675                }
1676
1677                mGotResult = true;
1678            }
1679
1680            return mResult;
1681        }
1682
1683        private  result_double2(Allocation out) {
1684            mTempIns = null;
1685            mOut = out;
1686            mGotResult = false;
1687        }
1688
1689        private Allocation[] mTempIns;
1690        private Allocation mOut;
1691        private boolean mGotResult;
1692        private Double2 mResult;
1693    }
1694
1695    // To obtain the result, invoke get(), which blocks
1696    // until the asynchronously-launched operation has completed.
1697    public static class result_double4 {
1698        public Double4 get() {
1699            if (!mGotResult) {
1700                double[] outArray = new double[4];
1701                mOut.copyTo(outArray);
1702                mResult = new Double4(outArray[0], outArray[1], outArray[2], outArray[3]);
1703                mOut.destroy();
1704                mOut = null;  // make Java object eligible for garbage collection
1705                if (mTempIns != null) {
1706                    for (Allocation tempIn : mTempIns) {
1707                        tempIn.destroy();
1708                    }
1709
1710                    mTempIns = null;  // make Java objects eligible for garbage collection
1711                }
1712
1713                mGotResult = true;
1714            }
1715
1716            return mResult;
1717        }
1718
1719        private  result_double4(Allocation out) {
1720            mTempIns = null;
1721            mOut = out;
1722            mGotResult = false;
1723        }
1724
1725        private Allocation[] mTempIns;
1726        private Allocation mOut;
1727        private boolean mGotResult;
1728        private Double4 mResult;
1729    }
1730
1731    // To obtain the result, invoke get(), which blocks
1732    // until the asynchronously-launched operation has completed.
1733    public static class result_float {
1734        public float get() {
1735            if (!mGotResult) {
1736                float[] outArray = new float[1];
1737                mOut.copyTo(outArray);
1738                mResult = outArray[0];
1739                mOut.destroy();
1740                mOut = null;  // make Java object eligible for garbage collection
1741                if (mTempIns != null) {
1742                    for (Allocation tempIn : mTempIns) {
1743                        tempIn.destroy();
1744                    }
1745
1746                    mTempIns = null;  // make Java objects eligible for garbage collection
1747                }
1748
1749                mGotResult = true;
1750            }
1751
1752            return mResult;
1753        }
1754
1755        private  result_float(Allocation out) {
1756            mTempIns = null;
1757            mOut = out;
1758            mGotResult = false;
1759        }
1760
1761        private Allocation[] mTempIns;
1762        private Allocation mOut;
1763        private boolean mGotResult;
1764        private float mResult;
1765    }
1766
1767    // To obtain the result, invoke get(), which blocks
1768    // until the asynchronously-launched operation has completed.
1769    public static class result_float2 {
1770        public Float2 get() {
1771            if (!mGotResult) {
1772                float[] outArray = new float[2];
1773                mOut.copyTo(outArray);
1774                mResult = new Float2(outArray[0], outArray[1]);
1775                mOut.destroy();
1776                mOut = null;  // make Java object eligible for garbage collection
1777                if (mTempIns != null) {
1778                    for (Allocation tempIn : mTempIns) {
1779                        tempIn.destroy();
1780                    }
1781
1782                    mTempIns = null;  // make Java objects eligible for garbage collection
1783                }
1784
1785                mGotResult = true;
1786            }
1787
1788            return mResult;
1789        }
1790
1791        private  result_float2(Allocation out) {
1792            mTempIns = null;
1793            mOut = out;
1794            mGotResult = false;
1795        }
1796
1797        private Allocation[] mTempIns;
1798        private Allocation mOut;
1799        private boolean mGotResult;
1800        private Float2 mResult;
1801    }
1802
1803    // To obtain the result, invoke get(), which blocks
1804    // until the asynchronously-launched operation has completed.
1805    public static class result_float4 {
1806        public Float4 get() {
1807            if (!mGotResult) {
1808                float[] outArray = new float[4];
1809                mOut.copyTo(outArray);
1810                mResult = new Float4(outArray[0], outArray[1], outArray[2], outArray[3]);
1811                mOut.destroy();
1812                mOut = null;  // make Java object eligible for garbage collection
1813                if (mTempIns != null) {
1814                    for (Allocation tempIn : mTempIns) {
1815                        tempIn.destroy();
1816                    }
1817
1818                    mTempIns = null;  // make Java objects eligible for garbage collection
1819                }
1820
1821                mGotResult = true;
1822            }
1823
1824            return mResult;
1825        }
1826
1827        private  result_float4(Allocation out) {
1828            mTempIns = null;
1829            mOut = out;
1830            mGotResult = false;
1831        }
1832
1833        private Allocation[] mTempIns;
1834        private Allocation mOut;
1835        private boolean mGotResult;
1836        private Float4 mResult;
1837    }
1838
1839    // To obtain the result, invoke get(), which blocks
1840    // until the asynchronously-launched operation has completed.
1841    public static class result_half {
1842        public short get() {
1843            if (!mGotResult) {
1844                short[] outArray = new short[1];
1845                mOut.copyTo(outArray);
1846                mResult = outArray[0];
1847                mOut.destroy();
1848                mOut = null;  // make Java object eligible for garbage collection
1849                if (mTempIns != null) {
1850                    for (Allocation tempIn : mTempIns) {
1851                        tempIn.destroy();
1852                    }
1853
1854                    mTempIns = null;  // make Java objects eligible for garbage collection
1855                }
1856
1857                mGotResult = true;
1858            }
1859
1860            return mResult;
1861        }
1862
1863        private  result_half(Allocation out) {
1864            mTempIns = null;
1865            mOut = out;
1866            mGotResult = false;
1867        }
1868
1869        private Allocation[] mTempIns;
1870        private Allocation mOut;
1871        private boolean mGotResult;
1872        private short mResult;
1873    }
1874
1875    // To obtain the result, invoke get(), which blocks
1876    // until the asynchronously-launched operation has completed.
1877    public static class result_half2 {
1878        public Short2 get() {
1879            if (!mGotResult) {
1880                short[] outArray = new short[2];
1881                mOut.copyTo(outArray);
1882                mResult = new Short2(outArray[0], outArray[1]);
1883                mOut.destroy();
1884                mOut = null;  // make Java object eligible for garbage collection
1885                if (mTempIns != null) {
1886                    for (Allocation tempIn : mTempIns) {
1887                        tempIn.destroy();
1888                    }
1889
1890                    mTempIns = null;  // make Java objects eligible for garbage collection
1891                }
1892
1893                mGotResult = true;
1894            }
1895
1896            return mResult;
1897        }
1898
1899        private  result_half2(Allocation out) {
1900            mTempIns = null;
1901            mOut = out;
1902            mGotResult = false;
1903        }
1904
1905        private Allocation[] mTempIns;
1906        private Allocation mOut;
1907        private boolean mGotResult;
1908        private Short2 mResult;
1909    }
1910
1911    // To obtain the result, invoke get(), which blocks
1912    // until the asynchronously-launched operation has completed.
1913    public static class result_half4 {
1914        public Short4 get() {
1915            if (!mGotResult) {
1916                short[] outArray = new short[4];
1917                mOut.copyTo(outArray);
1918                mResult = new Short4(outArray[0], outArray[1], outArray[2], outArray[3]);
1919                mOut.destroy();
1920                mOut = null;  // make Java object eligible for garbage collection
1921                if (mTempIns != null) {
1922                    for (Allocation tempIn : mTempIns) {
1923                        tempIn.destroy();
1924                    }
1925
1926                    mTempIns = null;  // make Java objects eligible for garbage collection
1927                }
1928
1929                mGotResult = true;
1930            }
1931
1932            return mResult;
1933        }
1934
1935        private  result_half4(Allocation out) {
1936            mTempIns = null;
1937            mOut = out;
1938            mGotResult = false;
1939        }
1940
1941        private Allocation[] mTempIns;
1942        private Allocation mOut;
1943        private boolean mGotResult;
1944        private Short4 mResult;
1945    }
1946
1947    // To obtain the result, invoke get(), which blocks
1948    // until the asynchronously-launched operation has completed.
1949    public static class result_int {
1950        public int get() {
1951            if (!mGotResult) {
1952                int[] outArray = new int[1];
1953                mOut.copyTo(outArray);
1954                mResult = outArray[0];
1955                mOut.destroy();
1956                mOut = null;  // make Java object eligible for garbage collection
1957                if (mTempIns != null) {
1958                    for (Allocation tempIn : mTempIns) {
1959                        tempIn.destroy();
1960                    }
1961
1962                    mTempIns = null;  // make Java objects eligible for garbage collection
1963                }
1964
1965                mGotResult = true;
1966            }
1967
1968            return mResult;
1969        }
1970
1971        private  result_int(Allocation out) {
1972            mTempIns = null;
1973            mOut = out;
1974            mGotResult = false;
1975        }
1976
1977        private Allocation[] mTempIns;
1978        private Allocation mOut;
1979        private boolean mGotResult;
1980        private int mResult;
1981    }
1982
1983    // To obtain the result, invoke get(), which blocks
1984    // until the asynchronously-launched operation has completed.
1985    public static class result_int2 {
1986        public Int2 get() {
1987            if (!mGotResult) {
1988                int[] outArray = new int[2];
1989                mOut.copyTo(outArray);
1990                mResult = new Int2(outArray[0], outArray[1]);
1991                mOut.destroy();
1992                mOut = null;  // make Java object eligible for garbage collection
1993                if (mTempIns != null) {
1994                    for (Allocation tempIn : mTempIns) {
1995                        tempIn.destroy();
1996                    }
1997
1998                    mTempIns = null;  // make Java objects eligible for garbage collection
1999                }
2000
2001                mGotResult = true;
2002            }
2003
2004            return mResult;
2005        }
2006
2007        private  result_int2(Allocation out) {
2008            mTempIns = null;
2009            mOut = out;
2010            mGotResult = false;
2011        }
2012
2013        private Allocation[] mTempIns;
2014        private Allocation mOut;
2015        private boolean mGotResult;
2016        private Int2 mResult;
2017    }
2018
2019    // To obtain the result, invoke get(), which blocks
2020    // until the asynchronously-launched operation has completed.
2021    public static class result_int4 {
2022        public Int4 get() {
2023            if (!mGotResult) {
2024                int[] outArray = new int[4];
2025                mOut.copyTo(outArray);
2026                mResult = new Int4(outArray[0], outArray[1], outArray[2], outArray[3]);
2027                mOut.destroy();
2028                mOut = null;  // make Java object eligible for garbage collection
2029                if (mTempIns != null) {
2030                    for (Allocation tempIn : mTempIns) {
2031                        tempIn.destroy();
2032                    }
2033
2034                    mTempIns = null;  // make Java objects eligible for garbage collection
2035                }
2036
2037                mGotResult = true;
2038            }
2039
2040            return mResult;
2041        }
2042
2043        private  result_int4(Allocation out) {
2044            mTempIns = null;
2045            mOut = out;
2046            mGotResult = false;
2047        }
2048
2049        private Allocation[] mTempIns;
2050        private Allocation mOut;
2051        private boolean mGotResult;
2052        private Int4 mResult;
2053    }
2054
2055    // To obtain the result, invoke get(), which blocks
2056    // until the asynchronously-launched operation has completed.
2057    public static class result_long {
2058        public long get() {
2059            if (!mGotResult) {
2060                long[] outArray = new long[1];
2061                mOut.copyTo(outArray);
2062                mResult = outArray[0];
2063                mOut.destroy();
2064                mOut = null;  // make Java object eligible for garbage collection
2065                if (mTempIns != null) {
2066                    for (Allocation tempIn : mTempIns) {
2067                        tempIn.destroy();
2068                    }
2069
2070                    mTempIns = null;  // make Java objects eligible for garbage collection
2071                }
2072
2073                mGotResult = true;
2074            }
2075
2076            return mResult;
2077        }
2078
2079        private  result_long(Allocation out) {
2080            mTempIns = null;
2081            mOut = out;
2082            mGotResult = false;
2083        }
2084
2085        private Allocation[] mTempIns;
2086        private Allocation mOut;
2087        private boolean mGotResult;
2088        private long mResult;
2089    }
2090
2091    // To obtain the result, invoke get(), which blocks
2092    // until the asynchronously-launched operation has completed.
2093    public static class result_long2 {
2094        public Long2 get() {
2095            if (!mGotResult) {
2096                long[] outArray = new long[2];
2097                mOut.copyTo(outArray);
2098                mResult = new Long2(outArray[0], outArray[1]);
2099                mOut.destroy();
2100                mOut = null;  // make Java object eligible for garbage collection
2101                if (mTempIns != null) {
2102                    for (Allocation tempIn : mTempIns) {
2103                        tempIn.destroy();
2104                    }
2105
2106                    mTempIns = null;  // make Java objects eligible for garbage collection
2107                }
2108
2109                mGotResult = true;
2110            }
2111
2112            return mResult;
2113        }
2114
2115        private  result_long2(Allocation out) {
2116            mTempIns = null;
2117            mOut = out;
2118            mGotResult = false;
2119        }
2120
2121        private Allocation[] mTempIns;
2122        private Allocation mOut;
2123        private boolean mGotResult;
2124        private Long2 mResult;
2125    }
2126
2127    // To obtain the result, invoke get(), which blocks
2128    // until the asynchronously-launched operation has completed.
2129    public static class result_long4 {
2130        public Long4 get() {
2131            if (!mGotResult) {
2132                long[] outArray = new long[4];
2133                mOut.copyTo(outArray);
2134                mResult = new Long4(outArray[0], outArray[1], outArray[2], outArray[3]);
2135                mOut.destroy();
2136                mOut = null;  // make Java object eligible for garbage collection
2137                if (mTempIns != null) {
2138                    for (Allocation tempIn : mTempIns) {
2139                        tempIn.destroy();
2140                    }
2141
2142                    mTempIns = null;  // make Java objects eligible for garbage collection
2143                }
2144
2145                mGotResult = true;
2146            }
2147
2148            return mResult;
2149        }
2150
2151        private  result_long4(Allocation out) {
2152            mTempIns = null;
2153            mOut = out;
2154            mGotResult = false;
2155        }
2156
2157        private Allocation[] mTempIns;
2158        private Allocation mOut;
2159        private boolean mGotResult;
2160        private Long4 mResult;
2161    }
2162
2163    // To obtain the result, invoke get(), which blocks
2164    // until the asynchronously-launched operation has completed.
2165    public static class result_short {
2166        public short get() {
2167            if (!mGotResult) {
2168                short[] outArray = new short[1];
2169                mOut.copyTo(outArray);
2170                mResult = outArray[0];
2171                mOut.destroy();
2172                mOut = null;  // make Java object eligible for garbage collection
2173                if (mTempIns != null) {
2174                    for (Allocation tempIn : mTempIns) {
2175                        tempIn.destroy();
2176                    }
2177
2178                    mTempIns = null;  // make Java objects eligible for garbage collection
2179                }
2180
2181                mGotResult = true;
2182            }
2183
2184            return mResult;
2185        }
2186
2187        private  result_short(Allocation out) {
2188            mTempIns = null;
2189            mOut = out;
2190            mGotResult = false;
2191        }
2192
2193        private Allocation[] mTempIns;
2194        private Allocation mOut;
2195        private boolean mGotResult;
2196        private short mResult;
2197    }
2198
2199    // To obtain the result, invoke get(), which blocks
2200    // until the asynchronously-launched operation has completed.
2201    public static class result_short2 {
2202        public Short2 get() {
2203            if (!mGotResult) {
2204                short[] outArray = new short[2];
2205                mOut.copyTo(outArray);
2206                mResult = new Short2(outArray[0], outArray[1]);
2207                mOut.destroy();
2208                mOut = null;  // make Java object eligible for garbage collection
2209                if (mTempIns != null) {
2210                    for (Allocation tempIn : mTempIns) {
2211                        tempIn.destroy();
2212                    }
2213
2214                    mTempIns = null;  // make Java objects eligible for garbage collection
2215                }
2216
2217                mGotResult = true;
2218            }
2219
2220            return mResult;
2221        }
2222
2223        private  result_short2(Allocation out) {
2224            mTempIns = null;
2225            mOut = out;
2226            mGotResult = false;
2227        }
2228
2229        private Allocation[] mTempIns;
2230        private Allocation mOut;
2231        private boolean mGotResult;
2232        private Short2 mResult;
2233    }
2234
2235    // To obtain the result, invoke get(), which blocks
2236    // until the asynchronously-launched operation has completed.
2237    public static class result_short4 {
2238        public Short4 get() {
2239            if (!mGotResult) {
2240                short[] outArray = new short[4];
2241                mOut.copyTo(outArray);
2242                mResult = new Short4(outArray[0], outArray[1], outArray[2], outArray[3]);
2243                mOut.destroy();
2244                mOut = null;  // make Java object eligible for garbage collection
2245                if (mTempIns != null) {
2246                    for (Allocation tempIn : mTempIns) {
2247                        tempIn.destroy();
2248                    }
2249
2250                    mTempIns = null;  // make Java objects eligible for garbage collection
2251                }
2252
2253                mGotResult = true;
2254            }
2255
2256            return mResult;
2257        }
2258
2259        private  result_short4(Allocation out) {
2260            mTempIns = null;
2261            mOut = out;
2262            mGotResult = false;
2263        }
2264
2265        private Allocation[] mTempIns;
2266        private Allocation mOut;
2267        private boolean mGotResult;
2268        private Short4 mResult;
2269    }
2270
2271    // To obtain the result, invoke get(), which blocks
2272    // until the asynchronously-launched operation has completed.
2273    public static class result_uchar {
2274        public short get() {
2275            if (!mGotResult) {
2276                byte[] outArray = new byte[1];
2277                mOut.copyTo(outArray);
2278                mResult = ((short) ((outArray[0]) & (short) 0xff));
2279                mOut.destroy();
2280                mOut = null;  // make Java object eligible for garbage collection
2281                if (mTempIns != null) {
2282                    for (Allocation tempIn : mTempIns) {
2283                        tempIn.destroy();
2284                    }
2285
2286                    mTempIns = null;  // make Java objects eligible for garbage collection
2287                }
2288
2289                mGotResult = true;
2290            }
2291
2292            return mResult;
2293        }
2294
2295        private  result_uchar(Allocation out) {
2296            mTempIns = null;
2297            mOut = out;
2298            mGotResult = false;
2299        }
2300
2301        private Allocation[] mTempIns;
2302        private Allocation mOut;
2303        private boolean mGotResult;
2304        private short mResult;
2305    }
2306
2307    // To obtain the result, invoke get(), which blocks
2308    // until the asynchronously-launched operation has completed.
2309    public static class result_uchar2 {
2310        public Short2 get() {
2311            if (!mGotResult) {
2312                byte[] outArray = new byte[2];
2313                mOut.copyTo(outArray);
2314                mResult = new Short2(((short) ((outArray[0]) & (short) 0xff)), ((short) ((outArray[1]) & (short) 0xff)));
2315                mOut.destroy();
2316                mOut = null;  // make Java object eligible for garbage collection
2317                if (mTempIns != null) {
2318                    for (Allocation tempIn : mTempIns) {
2319                        tempIn.destroy();
2320                    }
2321
2322                    mTempIns = null;  // make Java objects eligible for garbage collection
2323                }
2324
2325                mGotResult = true;
2326            }
2327
2328            return mResult;
2329        }
2330
2331        private  result_uchar2(Allocation out) {
2332            mTempIns = null;
2333            mOut = out;
2334            mGotResult = false;
2335        }
2336
2337        private Allocation[] mTempIns;
2338        private Allocation mOut;
2339        private boolean mGotResult;
2340        private Short2 mResult;
2341    }
2342
2343    // To obtain the result, invoke get(), which blocks
2344    // until the asynchronously-launched operation has completed.
2345    public static class result_uchar4 {
2346        public Short4 get() {
2347            if (!mGotResult) {
2348                byte[] outArray = new byte[4];
2349                mOut.copyTo(outArray);
2350                mResult = new Short4(((short) ((outArray[0]) & (short) 0xff)), ((short) ((outArray[1]) & (short) 0xff)), ((short) ((outArray[2]) & (short) 0xff)), ((short) ((outArray[3]) & (short) 0xff)));
2351                mOut.destroy();
2352                mOut = null;  // make Java object eligible for garbage collection
2353                if (mTempIns != null) {
2354                    for (Allocation tempIn : mTempIns) {
2355                        tempIn.destroy();
2356                    }
2357
2358                    mTempIns = null;  // make Java objects eligible for garbage collection
2359                }
2360
2361                mGotResult = true;
2362            }
2363
2364            return mResult;
2365        }
2366
2367        private  result_uchar4(Allocation out) {
2368            mTempIns = null;
2369            mOut = out;
2370            mGotResult = false;
2371        }
2372
2373        private Allocation[] mTempIns;
2374        private Allocation mOut;
2375        private boolean mGotResult;
2376        private Short4 mResult;
2377    }
2378
2379    // To obtain the result, invoke get(), which blocks
2380    // until the asynchronously-launched operation has completed.
2381    public static class result_uint {
2382        public long get() {
2383            if (!mGotResult) {
2384                int[] outArray = new int[1];
2385                mOut.copyTo(outArray);
2386                mResult = ((long) ((outArray[0]) & 0xffffffffL));
2387                mOut.destroy();
2388                mOut = null;  // make Java object eligible for garbage collection
2389                if (mTempIns != null) {
2390                    for (Allocation tempIn : mTempIns) {
2391                        tempIn.destroy();
2392                    }
2393
2394                    mTempIns = null;  // make Java objects eligible for garbage collection
2395                }
2396
2397                mGotResult = true;
2398            }
2399
2400            return mResult;
2401        }
2402
2403        private  result_uint(Allocation out) {
2404            mTempIns = null;
2405            mOut = out;
2406            mGotResult = false;
2407        }
2408
2409        private Allocation[] mTempIns;
2410        private Allocation mOut;
2411        private boolean mGotResult;
2412        private long mResult;
2413    }
2414
2415    // To obtain the result, invoke get(), which blocks
2416    // until the asynchronously-launched operation has completed.
2417    public static class result_uint2 {
2418        public Long2 get() {
2419            if (!mGotResult) {
2420                int[] outArray = new int[2];
2421                mOut.copyTo(outArray);
2422                mResult = new Long2(((long) ((outArray[0]) & 0xffffffffL)), ((long) ((outArray[1]) & 0xffffffffL)));
2423                mOut.destroy();
2424                mOut = null;  // make Java object eligible for garbage collection
2425                if (mTempIns != null) {
2426                    for (Allocation tempIn : mTempIns) {
2427                        tempIn.destroy();
2428                    }
2429
2430                    mTempIns = null;  // make Java objects eligible for garbage collection
2431                }
2432
2433                mGotResult = true;
2434            }
2435
2436            return mResult;
2437        }
2438
2439        private  result_uint2(Allocation out) {
2440            mTempIns = null;
2441            mOut = out;
2442            mGotResult = false;
2443        }
2444
2445        private Allocation[] mTempIns;
2446        private Allocation mOut;
2447        private boolean mGotResult;
2448        private Long2 mResult;
2449    }
2450
2451    // To obtain the result, invoke get(), which blocks
2452    // until the asynchronously-launched operation has completed.
2453    public static class result_uint4 {
2454        public Long4 get() {
2455            if (!mGotResult) {
2456                int[] outArray = new int[4];
2457                mOut.copyTo(outArray);
2458                mResult = new Long4(((long) ((outArray[0]) & 0xffffffffL)), ((long) ((outArray[1]) & 0xffffffffL)), ((long) ((outArray[2]) & 0xffffffffL)), ((long) ((outArray[3]) & 0xffffffffL)));
2459                mOut.destroy();
2460                mOut = null;  // make Java object eligible for garbage collection
2461                if (mTempIns != null) {
2462                    for (Allocation tempIn : mTempIns) {
2463                        tempIn.destroy();
2464                    }
2465
2466                    mTempIns = null;  // make Java objects eligible for garbage collection
2467                }
2468
2469                mGotResult = true;
2470            }
2471
2472            return mResult;
2473        }
2474
2475        private  result_uint4(Allocation out) {
2476            mTempIns = null;
2477            mOut = out;
2478            mGotResult = false;
2479        }
2480
2481        private Allocation[] mTempIns;
2482        private Allocation mOut;
2483        private boolean mGotResult;
2484        private Long4 mResult;
2485    }
2486
2487    // To obtain the result, invoke get(), which blocks
2488    // until the asynchronously-launched operation has completed.
2489    public static class result_ulong {
2490        public long get() {
2491            if (!mGotResult) {
2492                long[] outArray = new long[1];
2493                mOut.copyTo(outArray);
2494                if (outArray[0] < 0)
2495                    throw new RSRuntimeException("Result is not representible in Java");
2496                mResult = outArray[0];
2497                mOut.destroy();
2498                mOut = null;  // make Java object eligible for garbage collection
2499                if (mTempIns != null) {
2500                    for (Allocation tempIn : mTempIns) {
2501                        tempIn.destroy();
2502                    }
2503
2504                    mTempIns = null;  // make Java objects eligible for garbage collection
2505                }
2506
2507                mGotResult = true;
2508            }
2509
2510            return mResult;
2511        }
2512
2513        private  result_ulong(Allocation out) {
2514            mTempIns = null;
2515            mOut = out;
2516            mGotResult = false;
2517        }
2518
2519        private Allocation[] mTempIns;
2520        private Allocation mOut;
2521        private boolean mGotResult;
2522        private long mResult;
2523    }
2524
2525    // To obtain the result, invoke get(), which blocks
2526    // until the asynchronously-launched operation has completed.
2527    public static class result_ulong2 {
2528        public Long2 get() {
2529            if (!mGotResult) {
2530                long[] outArray = new long[2];
2531                mOut.copyTo(outArray);
2532                for (int Idx = 0; Idx < 2; ++Idx) {
2533                    if (outArray[Idx] < 0)
2534                        throw new RSRuntimeException("Result is not representible in Java");
2535                }
2536
2537                mResult = new Long2(outArray[0], outArray[1]);
2538                mOut.destroy();
2539                mOut = null;  // make Java object eligible for garbage collection
2540                if (mTempIns != null) {
2541                    for (Allocation tempIn : mTempIns) {
2542                        tempIn.destroy();
2543                    }
2544
2545                    mTempIns = null;  // make Java objects eligible for garbage collection
2546                }
2547
2548                mGotResult = true;
2549            }
2550
2551            return mResult;
2552        }
2553
2554        private  result_ulong2(Allocation out) {
2555            mTempIns = null;
2556            mOut = out;
2557            mGotResult = false;
2558        }
2559
2560        private Allocation[] mTempIns;
2561        private Allocation mOut;
2562        private boolean mGotResult;
2563        private Long2 mResult;
2564    }
2565
2566    // To obtain the result, invoke get(), which blocks
2567    // until the asynchronously-launched operation has completed.
2568    public static class result_ulong4 {
2569        public Long4 get() {
2570            if (!mGotResult) {
2571                long[] outArray = new long[4];
2572                mOut.copyTo(outArray);
2573                for (int Idx = 0; Idx < 4; ++Idx) {
2574                    if (outArray[Idx] < 0)
2575                        throw new RSRuntimeException("Result is not representible in Java");
2576                }
2577
2578                mResult = new Long4(outArray[0], outArray[1], outArray[2], outArray[3]);
2579                mOut.destroy();
2580                mOut = null;  // make Java object eligible for garbage collection
2581                if (mTempIns != null) {
2582                    for (Allocation tempIn : mTempIns) {
2583                        tempIn.destroy();
2584                    }
2585
2586                    mTempIns = null;  // make Java objects eligible for garbage collection
2587                }
2588
2589                mGotResult = true;
2590            }
2591
2592            return mResult;
2593        }
2594
2595        private  result_ulong4(Allocation out) {
2596            mTempIns = null;
2597            mOut = out;
2598            mGotResult = false;
2599        }
2600
2601        private Allocation[] mTempIns;
2602        private Allocation mOut;
2603        private boolean mGotResult;
2604        private Long4 mResult;
2605    }
2606
2607    // To obtain the result, invoke get(), which blocks
2608    // until the asynchronously-launched operation has completed.
2609    public static class result_ushort {
2610        public int get() {
2611            if (!mGotResult) {
2612                short[] outArray = new short[1];
2613                mOut.copyTo(outArray);
2614                mResult = ((int) ((outArray[0]) & 0xffff));
2615                mOut.destroy();
2616                mOut = null;  // make Java object eligible for garbage collection
2617                if (mTempIns != null) {
2618                    for (Allocation tempIn : mTempIns) {
2619                        tempIn.destroy();
2620                    }
2621
2622                    mTempIns = null;  // make Java objects eligible for garbage collection
2623                }
2624
2625                mGotResult = true;
2626            }
2627
2628            return mResult;
2629        }
2630
2631        private  result_ushort(Allocation out) {
2632            mTempIns = null;
2633            mOut = out;
2634            mGotResult = false;
2635        }
2636
2637        private Allocation[] mTempIns;
2638        private Allocation mOut;
2639        private boolean mGotResult;
2640        private int mResult;
2641    }
2642
2643    // To obtain the result, invoke get(), which blocks
2644    // until the asynchronously-launched operation has completed.
2645    public static class result_ushort2 {
2646        public Int2 get() {
2647            if (!mGotResult) {
2648                short[] outArray = new short[2];
2649                mOut.copyTo(outArray);
2650                mResult = new Int2(((int) ((outArray[0]) & 0xffff)), ((int) ((outArray[1]) & 0xffff)));
2651                mOut.destroy();
2652                mOut = null;  // make Java object eligible for garbage collection
2653                if (mTempIns != null) {
2654                    for (Allocation tempIn : mTempIns) {
2655                        tempIn.destroy();
2656                    }
2657
2658                    mTempIns = null;  // make Java objects eligible for garbage collection
2659                }
2660
2661                mGotResult = true;
2662            }
2663
2664            return mResult;
2665        }
2666
2667        private  result_ushort2(Allocation out) {
2668            mTempIns = null;
2669            mOut = out;
2670            mGotResult = false;
2671        }
2672
2673        private Allocation[] mTempIns;
2674        private Allocation mOut;
2675        private boolean mGotResult;
2676        private Int2 mResult;
2677    }
2678
2679    // To obtain the result, invoke get(), which blocks
2680    // until the asynchronously-launched operation has completed.
2681    public static class result_ushort4 {
2682        public Int4 get() {
2683            if (!mGotResult) {
2684                short[] outArray = new short[4];
2685                mOut.copyTo(outArray);
2686                mResult = new Int4(((int) ((outArray[0]) & 0xffff)), ((int) ((outArray[1]) & 0xffff)), ((int) ((outArray[2]) & 0xffff)), ((int) ((outArray[3]) & 0xffff)));
2687                mOut.destroy();
2688                mOut = null;  // make Java object eligible for garbage collection
2689                if (mTempIns != null) {
2690                    for (Allocation tempIn : mTempIns) {
2691                        tempIn.destroy();
2692                    }
2693
2694                    mTempIns = null;  // make Java objects eligible for garbage collection
2695                }
2696
2697                mGotResult = true;
2698            }
2699
2700            return mResult;
2701        }
2702
2703        private  result_ushort4(Allocation out) {
2704            mTempIns = null;
2705            mOut = out;
2706            mGotResult = false;
2707        }
2708
2709        private Allocation[] mTempIns;
2710        private Allocation mOut;
2711        private boolean mGotResult;
2712        private Int4 mResult;
2713    }
2714
2715    private final static int mExportReduceIdx_my_half = 0;
2716    // in1 = "val"
2717    public result_half reduce_my_half(short[] in1) {
2718        // Verify that "in1" is non-null.
2719        if (in1 == null) {
2720            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2721        }
2722        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
2723        ain1.setAutoPadding(true);
2724        ain1.copyFrom(in1);
2725
2726        result_half result = reduce_my_half(ain1, null);
2727        result.mTempIns = new Allocation[]{ain1};
2728        return result;
2729    }
2730
2731    // ain1 = "half val"
2732    public result_half reduce_my_half(Allocation ain1) {
2733        return reduce_my_half(ain1, null);
2734    }
2735
2736    // ain1 = "half val"
2737    public result_half reduce_my_half(Allocation ain1, Script.LaunchOptions sc) {
2738        // check ain1
2739        if (!ain1.getType().getElement().isCompatible(__F16)) {
2740            throw new RSRuntimeException("Type mismatch with F16!");
2741        }
2742        Allocation aout = Allocation.createSized(mRSLocal, __F16, 1);
2743        aout.setAutoPadding(true);
2744        reduce(mExportReduceIdx_my_half, new Allocation[]{ain1}, aout, sc);
2745        return new result_half(aout);
2746    }
2747
2748    private final static int mExportReduceIdx_my_half2 = 1;
2749    // in1 = "val", flattened 2-vectors
2750    public result_half2 reduce_my_half2(short[] in1) {
2751        // Verify that "in1" is non-null.
2752        if (in1 == null) {
2753            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2754        }
2755        // Verify that the array length is a multiple of the vector size.
2756        if (in1.length % 2 != 0) {
2757            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2758        }
2759        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
2760        ain1.setAutoPadding(true);
2761        ain1.copyFrom(in1);
2762
2763        result_half2 result = reduce_my_half2(ain1, null);
2764        result.mTempIns = new Allocation[]{ain1};
2765        return result;
2766    }
2767
2768    // ain1 = "half2 val"
2769    public result_half2 reduce_my_half2(Allocation ain1) {
2770        return reduce_my_half2(ain1, null);
2771    }
2772
2773    // ain1 = "half2 val"
2774    public result_half2 reduce_my_half2(Allocation ain1, Script.LaunchOptions sc) {
2775        // check ain1
2776        if (!ain1.getType().getElement().isCompatible(__F16_2)) {
2777            throw new RSRuntimeException("Type mismatch with F16_2!");
2778        }
2779        Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 1);
2780        aout.setAutoPadding(true);
2781        reduce(mExportReduceIdx_my_half2, new Allocation[]{ain1}, aout, sc);
2782        return new result_half2(aout);
2783    }
2784
2785    private final static int mExportReduceIdx_my_half4 = 2;
2786    // in1 = "val", flattened 4-vectors
2787    public result_half4 reduce_my_half4(short[] in1) {
2788        // Verify that "in1" is non-null.
2789        if (in1 == null) {
2790            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2791        }
2792        // Verify that the array length is a multiple of the vector size.
2793        if (in1.length % 4 != 0) {
2794            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
2795        }
2796        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
2797        ain1.setAutoPadding(true);
2798        ain1.copyFrom(in1);
2799
2800        result_half4 result = reduce_my_half4(ain1, null);
2801        result.mTempIns = new Allocation[]{ain1};
2802        return result;
2803    }
2804
2805    // ain1 = "half4 val"
2806    public result_half4 reduce_my_half4(Allocation ain1) {
2807        return reduce_my_half4(ain1, null);
2808    }
2809
2810    // ain1 = "half4 val"
2811    public result_half4 reduce_my_half4(Allocation ain1, Script.LaunchOptions sc) {
2812        // check ain1
2813        if (!ain1.getType().getElement().isCompatible(__F16_4)) {
2814            throw new RSRuntimeException("Type mismatch with F16_4!");
2815        }
2816        Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 1);
2817        aout.setAutoPadding(true);
2818        reduce(mExportReduceIdx_my_half4, new Allocation[]{ain1}, aout, sc);
2819        return new result_half4(aout);
2820    }
2821
2822    private final static int mExportReduceIdx_my_array_half = 3;
2823    // in1 = "val"
2824    public resultArray7_half reduce_my_array_half(short[] in1) {
2825        // Verify that "in1" is non-null.
2826        if (in1 == null) {
2827            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2828        }
2829        Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
2830        ain1.setAutoPadding(true);
2831        ain1.copyFrom(in1);
2832
2833        resultArray7_half result = reduce_my_array_half(ain1, null);
2834        result.mTempIns = new Allocation[]{ain1};
2835        return result;
2836    }
2837
2838    // ain1 = "half val"
2839    public resultArray7_half reduce_my_array_half(Allocation ain1) {
2840        return reduce_my_array_half(ain1, null);
2841    }
2842
2843    // ain1 = "half val"
2844    public resultArray7_half reduce_my_array_half(Allocation ain1, Script.LaunchOptions sc) {
2845        // check ain1
2846        if (!ain1.getType().getElement().isCompatible(__F16)) {
2847            throw new RSRuntimeException("Type mismatch with F16!");
2848        }
2849        Allocation aout = Allocation.createSized(mRSLocal, __F16, 7);
2850        aout.setAutoPadding(true);
2851        reduce(mExportReduceIdx_my_array_half, new Allocation[]{ain1}, aout, sc);
2852        return new resultArray7_half(aout);
2853    }
2854
2855    private final static int mExportReduceIdx_my_array_half2 = 4;
2856    // in1 = "val", flattened 2-vectors
2857    public resultArray7_half2 reduce_my_array_half2(short[] in1) {
2858        // Verify that "in1" is non-null.
2859        if (in1 == null) {
2860            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2861        }
2862        // Verify that the array length is a multiple of the vector size.
2863        if (in1.length % 2 != 0) {
2864            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2865        }
2866        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
2867        ain1.setAutoPadding(true);
2868        ain1.copyFrom(in1);
2869
2870        resultArray7_half2 result = reduce_my_array_half2(ain1, null);
2871        result.mTempIns = new Allocation[]{ain1};
2872        return result;
2873    }
2874
2875    // ain1 = "half2 val"
2876    public resultArray7_half2 reduce_my_array_half2(Allocation ain1) {
2877        return reduce_my_array_half2(ain1, null);
2878    }
2879
2880    // ain1 = "half2 val"
2881    public resultArray7_half2 reduce_my_array_half2(Allocation ain1, Script.LaunchOptions sc) {
2882        // check ain1
2883        if (!ain1.getType().getElement().isCompatible(__F16_2)) {
2884            throw new RSRuntimeException("Type mismatch with F16_2!");
2885        }
2886        Allocation aout = Allocation.createSized(mRSLocal, __F16_2, 7);
2887        aout.setAutoPadding(true);
2888        reduce(mExportReduceIdx_my_array_half2, new Allocation[]{ain1}, aout, sc);
2889        return new resultArray7_half2(aout);
2890    }
2891
2892    private final static int mExportReduceIdx_my_array_half4 = 5;
2893    // in1 = "val", flattened 4-vectors
2894    public resultArray7_half4 reduce_my_array_half4(short[] in1) {
2895        // Verify that "in1" is non-null.
2896        if (in1 == null) {
2897            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2898        }
2899        // Verify that the array length is a multiple of the vector size.
2900        if (in1.length % 4 != 0) {
2901            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
2902        }
2903        Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
2904        ain1.setAutoPadding(true);
2905        ain1.copyFrom(in1);
2906
2907        resultArray7_half4 result = reduce_my_array_half4(ain1, null);
2908        result.mTempIns = new Allocation[]{ain1};
2909        return result;
2910    }
2911
2912    // ain1 = "half4 val"
2913    public resultArray7_half4 reduce_my_array_half4(Allocation ain1) {
2914        return reduce_my_array_half4(ain1, null);
2915    }
2916
2917    // ain1 = "half4 val"
2918    public resultArray7_half4 reduce_my_array_half4(Allocation ain1, Script.LaunchOptions sc) {
2919        // check ain1
2920        if (!ain1.getType().getElement().isCompatible(__F16_4)) {
2921            throw new RSRuntimeException("Type mismatch with F16_4!");
2922        }
2923        Allocation aout = Allocation.createSized(mRSLocal, __F16_4, 7);
2924        aout.setAutoPadding(true);
2925        reduce(mExportReduceIdx_my_array_half4, new Allocation[]{ain1}, aout, sc);
2926        return new resultArray7_half4(aout);
2927    }
2928
2929    private final static int mExportReduceIdx_my_float = 6;
2930    // in1 = "val"
2931    public result_float reduce_my_float(float[] in1) {
2932        // Verify that "in1" is non-null.
2933        if (in1 == null) {
2934            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2935        }
2936        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2937        ain1.setAutoPadding(true);
2938        ain1.copyFrom(in1);
2939
2940        result_float result = reduce_my_float(ain1, null);
2941        result.mTempIns = new Allocation[]{ain1};
2942        return result;
2943    }
2944
2945    // ain1 = "float val"
2946    public result_float reduce_my_float(Allocation ain1) {
2947        return reduce_my_float(ain1, null);
2948    }
2949
2950    // ain1 = "float val"
2951    public result_float reduce_my_float(Allocation ain1, Script.LaunchOptions sc) {
2952        // check ain1
2953        if (!ain1.getType().getElement().isCompatible(__F32)) {
2954            throw new RSRuntimeException("Type mismatch with F32!");
2955        }
2956        Allocation aout = Allocation.createSized(mRSLocal, __F32, 1);
2957        aout.setAutoPadding(true);
2958        reduce(mExportReduceIdx_my_float, new Allocation[]{ain1}, aout, sc);
2959        return new result_float(aout);
2960    }
2961
2962    private final static int mExportReduceIdx_my_float2 = 7;
2963    // in1 = "val", flattened 2-vectors
2964    public result_float2 reduce_my_float2(float[] in1) {
2965        // Verify that "in1" is non-null.
2966        if (in1 == null) {
2967            throw new RSIllegalArgumentException("Array \"in1\" is null!");
2968        }
2969        // Verify that the array length is a multiple of the vector size.
2970        if (in1.length % 2 != 0) {
2971            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2972        }
2973        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2974        ain1.setAutoPadding(true);
2975        ain1.copyFrom(in1);
2976
2977        result_float2 result = reduce_my_float2(ain1, null);
2978        result.mTempIns = new Allocation[]{ain1};
2979        return result;
2980    }
2981
2982    // ain1 = "float2 val"
2983    public result_float2 reduce_my_float2(Allocation ain1) {
2984        return reduce_my_float2(ain1, null);
2985    }
2986
2987    // ain1 = "float2 val"
2988    public result_float2 reduce_my_float2(Allocation ain1, Script.LaunchOptions sc) {
2989        // check ain1
2990        if (!ain1.getType().getElement().isCompatible(__F32_2)) {
2991            throw new RSRuntimeException("Type mismatch with F32_2!");
2992        }
2993        Allocation aout = Allocation.createSized(mRSLocal, __F32_2, 1);
2994        aout.setAutoPadding(true);
2995        reduce(mExportReduceIdx_my_float2, new Allocation[]{ain1}, aout, sc);
2996        return new result_float2(aout);
2997    }
2998
2999    private final static int mExportReduceIdx_my_float4 = 8;
3000    // in1 = "val", flattened 4-vectors
3001    public result_float4 reduce_my_float4(float[] in1) {
3002        // Verify that "in1" is non-null.
3003        if (in1 == null) {
3004            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3005        }
3006        // Verify that the array length is a multiple of the vector size.
3007        if (in1.length % 4 != 0) {
3008            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3009        }
3010        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3011        ain1.setAutoPadding(true);
3012        ain1.copyFrom(in1);
3013
3014        result_float4 result = reduce_my_float4(ain1, null);
3015        result.mTempIns = new Allocation[]{ain1};
3016        return result;
3017    }
3018
3019    // ain1 = "float4 val"
3020    public result_float4 reduce_my_float4(Allocation ain1) {
3021        return reduce_my_float4(ain1, null);
3022    }
3023
3024    // ain1 = "float4 val"
3025    public result_float4 reduce_my_float4(Allocation ain1, Script.LaunchOptions sc) {
3026        // check ain1
3027        if (!ain1.getType().getElement().isCompatible(__F32_4)) {
3028            throw new RSRuntimeException("Type mismatch with F32_4!");
3029        }
3030        Allocation aout = Allocation.createSized(mRSLocal, __F32_4, 1);
3031        aout.setAutoPadding(true);
3032        reduce(mExportReduceIdx_my_float4, new Allocation[]{ain1}, aout, sc);
3033        return new result_float4(aout);
3034    }
3035
3036    private final static int mExportReduceIdx_my_array_float = 9;
3037    // in1 = "val"
3038    public resultArray7_float reduce_my_array_float(float[] in1) {
3039        // Verify that "in1" is non-null.
3040        if (in1 == null) {
3041            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3042        }
3043        Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
3044        ain1.setAutoPadding(true);
3045        ain1.copyFrom(in1);
3046
3047        resultArray7_float result = reduce_my_array_float(ain1, null);
3048        result.mTempIns = new Allocation[]{ain1};
3049        return result;
3050    }
3051
3052    // ain1 = "float val"
3053    public resultArray7_float reduce_my_array_float(Allocation ain1) {
3054        return reduce_my_array_float(ain1, null);
3055    }
3056
3057    // ain1 = "float val"
3058    public resultArray7_float reduce_my_array_float(Allocation ain1, Script.LaunchOptions sc) {
3059        // check ain1
3060        if (!ain1.getType().getElement().isCompatible(__F32)) {
3061            throw new RSRuntimeException("Type mismatch with F32!");
3062        }
3063        Allocation aout = Allocation.createSized(mRSLocal, __F32, 7);
3064        aout.setAutoPadding(true);
3065        reduce(mExportReduceIdx_my_array_float, new Allocation[]{ain1}, aout, sc);
3066        return new resultArray7_float(aout);
3067    }
3068
3069    private final static int mExportReduceIdx_my_array_float2 = 10;
3070    // in1 = "val", flattened 2-vectors
3071    public resultArray7_float2 reduce_my_array_float2(float[] in1) {
3072        // Verify that "in1" is non-null.
3073        if (in1 == null) {
3074            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3075        }
3076        // Verify that the array length is a multiple of the vector size.
3077        if (in1.length % 2 != 0) {
3078            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3079        }
3080        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
3081        ain1.setAutoPadding(true);
3082        ain1.copyFrom(in1);
3083
3084        resultArray7_float2 result = reduce_my_array_float2(ain1, null);
3085        result.mTempIns = new Allocation[]{ain1};
3086        return result;
3087    }
3088
3089    // ain1 = "float2 val"
3090    public resultArray7_float2 reduce_my_array_float2(Allocation ain1) {
3091        return reduce_my_array_float2(ain1, null);
3092    }
3093
3094    // ain1 = "float2 val"
3095    public resultArray7_float2 reduce_my_array_float2(Allocation ain1, Script.LaunchOptions sc) {
3096        // check ain1
3097        if (!ain1.getType().getElement().isCompatible(__F32_2)) {
3098            throw new RSRuntimeException("Type mismatch with F32_2!");
3099        }
3100        Allocation aout = Allocation.createSized(mRSLocal, __F32_2, 7);
3101        aout.setAutoPadding(true);
3102        reduce(mExportReduceIdx_my_array_float2, new Allocation[]{ain1}, aout, sc);
3103        return new resultArray7_float2(aout);
3104    }
3105
3106    private final static int mExportReduceIdx_my_array_float4 = 11;
3107    // in1 = "val", flattened 4-vectors
3108    public resultArray7_float4 reduce_my_array_float4(float[] in1) {
3109        // Verify that "in1" is non-null.
3110        if (in1 == null) {
3111            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3112        }
3113        // Verify that the array length is a multiple of the vector size.
3114        if (in1.length % 4 != 0) {
3115            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3116        }
3117        Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3118        ain1.setAutoPadding(true);
3119        ain1.copyFrom(in1);
3120
3121        resultArray7_float4 result = reduce_my_array_float4(ain1, null);
3122        result.mTempIns = new Allocation[]{ain1};
3123        return result;
3124    }
3125
3126    // ain1 = "float4 val"
3127    public resultArray7_float4 reduce_my_array_float4(Allocation ain1) {
3128        return reduce_my_array_float4(ain1, null);
3129    }
3130
3131    // ain1 = "float4 val"
3132    public resultArray7_float4 reduce_my_array_float4(Allocation ain1, Script.LaunchOptions sc) {
3133        // check ain1
3134        if (!ain1.getType().getElement().isCompatible(__F32_4)) {
3135            throw new RSRuntimeException("Type mismatch with F32_4!");
3136        }
3137        Allocation aout = Allocation.createSized(mRSLocal, __F32_4, 7);
3138        aout.setAutoPadding(true);
3139        reduce(mExportReduceIdx_my_array_float4, new Allocation[]{ain1}, aout, sc);
3140        return new resultArray7_float4(aout);
3141    }
3142
3143    private final static int mExportReduceIdx_my_double = 12;
3144    // in1 = "val"
3145    public result_double reduce_my_double(double[] in1) {
3146        // Verify that "in1" is non-null.
3147        if (in1 == null) {
3148            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3149        }
3150        Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3151        ain1.setAutoPadding(true);
3152        ain1.copyFrom(in1);
3153
3154        result_double result = reduce_my_double(ain1, null);
3155        result.mTempIns = new Allocation[]{ain1};
3156        return result;
3157    }
3158
3159    // ain1 = "double val"
3160    public result_double reduce_my_double(Allocation ain1) {
3161        return reduce_my_double(ain1, null);
3162    }
3163
3164    // ain1 = "double val"
3165    public result_double reduce_my_double(Allocation ain1, Script.LaunchOptions sc) {
3166        // check ain1
3167        if (!ain1.getType().getElement().isCompatible(__F64)) {
3168            throw new RSRuntimeException("Type mismatch with F64!");
3169        }
3170        Allocation aout = Allocation.createSized(mRSLocal, __F64, 1);
3171        aout.setAutoPadding(true);
3172        reduce(mExportReduceIdx_my_double, new Allocation[]{ain1}, aout, sc);
3173        return new result_double(aout);
3174    }
3175
3176    private final static int mExportReduceIdx_my_double2 = 13;
3177    // in1 = "val", flattened 2-vectors
3178    public result_double2 reduce_my_double2(double[] in1) {
3179        // Verify that "in1" is non-null.
3180        if (in1 == null) {
3181            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3182        }
3183        // Verify that the array length is a multiple of the vector size.
3184        if (in1.length % 2 != 0) {
3185            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3186        }
3187        Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
3188        ain1.setAutoPadding(true);
3189        ain1.copyFrom(in1);
3190
3191        result_double2 result = reduce_my_double2(ain1, null);
3192        result.mTempIns = new Allocation[]{ain1};
3193        return result;
3194    }
3195
3196    // ain1 = "double2 val"
3197    public result_double2 reduce_my_double2(Allocation ain1) {
3198        return reduce_my_double2(ain1, null);
3199    }
3200
3201    // ain1 = "double2 val"
3202    public result_double2 reduce_my_double2(Allocation ain1, Script.LaunchOptions sc) {
3203        // check ain1
3204        if (!ain1.getType().getElement().isCompatible(__F64_2)) {
3205            throw new RSRuntimeException("Type mismatch with F64_2!");
3206        }
3207        Allocation aout = Allocation.createSized(mRSLocal, __F64_2, 1);
3208        aout.setAutoPadding(true);
3209        reduce(mExportReduceIdx_my_double2, new Allocation[]{ain1}, aout, sc);
3210        return new result_double2(aout);
3211    }
3212
3213    private final static int mExportReduceIdx_my_double4 = 14;
3214    // in1 = "val", flattened 4-vectors
3215    public result_double4 reduce_my_double4(double[] in1) {
3216        // Verify that "in1" is non-null.
3217        if (in1 == null) {
3218            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3219        }
3220        // Verify that the array length is a multiple of the vector size.
3221        if (in1.length % 4 != 0) {
3222            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3223        }
3224        Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
3225        ain1.setAutoPadding(true);
3226        ain1.copyFrom(in1);
3227
3228        result_double4 result = reduce_my_double4(ain1, null);
3229        result.mTempIns = new Allocation[]{ain1};
3230        return result;
3231    }
3232
3233    // ain1 = "double4 val"
3234    public result_double4 reduce_my_double4(Allocation ain1) {
3235        return reduce_my_double4(ain1, null);
3236    }
3237
3238    // ain1 = "double4 val"
3239    public result_double4 reduce_my_double4(Allocation ain1, Script.LaunchOptions sc) {
3240        // check ain1
3241        if (!ain1.getType().getElement().isCompatible(__F64_4)) {
3242            throw new RSRuntimeException("Type mismatch with F64_4!");
3243        }
3244        Allocation aout = Allocation.createSized(mRSLocal, __F64_4, 1);
3245        aout.setAutoPadding(true);
3246        reduce(mExportReduceIdx_my_double4, new Allocation[]{ain1}, aout, sc);
3247        return new result_double4(aout);
3248    }
3249
3250    private final static int mExportReduceIdx_my_array_double = 15;
3251    // in1 = "val"
3252    public resultArray7_double reduce_my_array_double(double[] in1) {
3253        // Verify that "in1" is non-null.
3254        if (in1 == null) {
3255            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3256        }
3257        Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3258        ain1.setAutoPadding(true);
3259        ain1.copyFrom(in1);
3260
3261        resultArray7_double result = reduce_my_array_double(ain1, null);
3262        result.mTempIns = new Allocation[]{ain1};
3263        return result;
3264    }
3265
3266    // ain1 = "double val"
3267    public resultArray7_double reduce_my_array_double(Allocation ain1) {
3268        return reduce_my_array_double(ain1, null);
3269    }
3270
3271    // ain1 = "double val"
3272    public resultArray7_double reduce_my_array_double(Allocation ain1, Script.LaunchOptions sc) {
3273        // check ain1
3274        if (!ain1.getType().getElement().isCompatible(__F64)) {
3275            throw new RSRuntimeException("Type mismatch with F64!");
3276        }
3277        Allocation aout = Allocation.createSized(mRSLocal, __F64, 7);
3278        aout.setAutoPadding(true);
3279        reduce(mExportReduceIdx_my_array_double, new Allocation[]{ain1}, aout, sc);
3280        return new resultArray7_double(aout);
3281    }
3282
3283    private final static int mExportReduceIdx_my_array_double2 = 16;
3284    // in1 = "val", flattened 2-vectors
3285    public resultArray7_double2 reduce_my_array_double2(double[] in1) {
3286        // Verify that "in1" is non-null.
3287        if (in1 == null) {
3288            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3289        }
3290        // Verify that the array length is a multiple of the vector size.
3291        if (in1.length % 2 != 0) {
3292            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3293        }
3294        Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
3295        ain1.setAutoPadding(true);
3296        ain1.copyFrom(in1);
3297
3298        resultArray7_double2 result = reduce_my_array_double2(ain1, null);
3299        result.mTempIns = new Allocation[]{ain1};
3300        return result;
3301    }
3302
3303    // ain1 = "double2 val"
3304    public resultArray7_double2 reduce_my_array_double2(Allocation ain1) {
3305        return reduce_my_array_double2(ain1, null);
3306    }
3307
3308    // ain1 = "double2 val"
3309    public resultArray7_double2 reduce_my_array_double2(Allocation ain1, Script.LaunchOptions sc) {
3310        // check ain1
3311        if (!ain1.getType().getElement().isCompatible(__F64_2)) {
3312            throw new RSRuntimeException("Type mismatch with F64_2!");
3313        }
3314        Allocation aout = Allocation.createSized(mRSLocal, __F64_2, 7);
3315        aout.setAutoPadding(true);
3316        reduce(mExportReduceIdx_my_array_double2, new Allocation[]{ain1}, aout, sc);
3317        return new resultArray7_double2(aout);
3318    }
3319
3320    private final static int mExportReduceIdx_my_array_double4 = 17;
3321    // in1 = "val", flattened 4-vectors
3322    public resultArray7_double4 reduce_my_array_double4(double[] in1) {
3323        // Verify that "in1" is non-null.
3324        if (in1 == null) {
3325            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3326        }
3327        // Verify that the array length is a multiple of the vector size.
3328        if (in1.length % 4 != 0) {
3329            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3330        }
3331        Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
3332        ain1.setAutoPadding(true);
3333        ain1.copyFrom(in1);
3334
3335        resultArray7_double4 result = reduce_my_array_double4(ain1, null);
3336        result.mTempIns = new Allocation[]{ain1};
3337        return result;
3338    }
3339
3340    // ain1 = "double4 val"
3341    public resultArray7_double4 reduce_my_array_double4(Allocation ain1) {
3342        return reduce_my_array_double4(ain1, null);
3343    }
3344
3345    // ain1 = "double4 val"
3346    public resultArray7_double4 reduce_my_array_double4(Allocation ain1, Script.LaunchOptions sc) {
3347        // check ain1
3348        if (!ain1.getType().getElement().isCompatible(__F64_4)) {
3349            throw new RSRuntimeException("Type mismatch with F64_4!");
3350        }
3351        Allocation aout = Allocation.createSized(mRSLocal, __F64_4, 7);
3352        aout.setAutoPadding(true);
3353        reduce(mExportReduceIdx_my_array_double4, new Allocation[]{ain1}, aout, sc);
3354        return new resultArray7_double4(aout);
3355    }
3356
3357    private final static int mExportReduceIdx_my_char = 18;
3358    // in1 = "val"
3359    public result_char reduce_my_char(byte[] in1) {
3360        // Verify that "in1" is non-null.
3361        if (in1 == null) {
3362            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3363        }
3364        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
3365        ain1.setAutoPadding(true);
3366        ain1.copyFrom(in1);
3367
3368        result_char result = reduce_my_char(ain1, null);
3369        result.mTempIns = new Allocation[]{ain1};
3370        return result;
3371    }
3372
3373    // ain1 = "char val"
3374    public result_char reduce_my_char(Allocation ain1) {
3375        return reduce_my_char(ain1, null);
3376    }
3377
3378    // ain1 = "char val"
3379    public result_char reduce_my_char(Allocation ain1, Script.LaunchOptions sc) {
3380        // check ain1
3381        if (!ain1.getType().getElement().isCompatible(__I8)) {
3382            throw new RSRuntimeException("Type mismatch with I8!");
3383        }
3384        Allocation aout = Allocation.createSized(mRSLocal, __I8, 1);
3385        aout.setAutoPadding(true);
3386        reduce(mExportReduceIdx_my_char, new Allocation[]{ain1}, aout, sc);
3387        return new result_char(aout);
3388    }
3389
3390    private final static int mExportReduceIdx_my_char2 = 19;
3391    // in1 = "val", flattened 2-vectors
3392    public result_char2 reduce_my_char2(byte[] in1) {
3393        // Verify that "in1" is non-null.
3394        if (in1 == null) {
3395            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3396        }
3397        // Verify that the array length is a multiple of the vector size.
3398        if (in1.length % 2 != 0) {
3399            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3400        }
3401        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
3402        ain1.setAutoPadding(true);
3403        ain1.copyFrom(in1);
3404
3405        result_char2 result = reduce_my_char2(ain1, null);
3406        result.mTempIns = new Allocation[]{ain1};
3407        return result;
3408    }
3409
3410    // ain1 = "char2 val"
3411    public result_char2 reduce_my_char2(Allocation ain1) {
3412        return reduce_my_char2(ain1, null);
3413    }
3414
3415    // ain1 = "char2 val"
3416    public result_char2 reduce_my_char2(Allocation ain1, Script.LaunchOptions sc) {
3417        // check ain1
3418        if (!ain1.getType().getElement().isCompatible(__I8_2)) {
3419            throw new RSRuntimeException("Type mismatch with I8_2!");
3420        }
3421        Allocation aout = Allocation.createSized(mRSLocal, __I8_2, 1);
3422        aout.setAutoPadding(true);
3423        reduce(mExportReduceIdx_my_char2, new Allocation[]{ain1}, aout, sc);
3424        return new result_char2(aout);
3425    }
3426
3427    private final static int mExportReduceIdx_my_char4 = 20;
3428    // in1 = "val", flattened 4-vectors
3429    public result_char4 reduce_my_char4(byte[] in1) {
3430        // Verify that "in1" is non-null.
3431        if (in1 == null) {
3432            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3433        }
3434        // Verify that the array length is a multiple of the vector size.
3435        if (in1.length % 4 != 0) {
3436            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3437        }
3438        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
3439        ain1.setAutoPadding(true);
3440        ain1.copyFrom(in1);
3441
3442        result_char4 result = reduce_my_char4(ain1, null);
3443        result.mTempIns = new Allocation[]{ain1};
3444        return result;
3445    }
3446
3447    // ain1 = "char4 val"
3448    public result_char4 reduce_my_char4(Allocation ain1) {
3449        return reduce_my_char4(ain1, null);
3450    }
3451
3452    // ain1 = "char4 val"
3453    public result_char4 reduce_my_char4(Allocation ain1, Script.LaunchOptions sc) {
3454        // check ain1
3455        if (!ain1.getType().getElement().isCompatible(__I8_4)) {
3456            throw new RSRuntimeException("Type mismatch with I8_4!");
3457        }
3458        Allocation aout = Allocation.createSized(mRSLocal, __I8_4, 1);
3459        aout.setAutoPadding(true);
3460        reduce(mExportReduceIdx_my_char4, new Allocation[]{ain1}, aout, sc);
3461        return new result_char4(aout);
3462    }
3463
3464    private final static int mExportReduceIdx_my_array_char = 21;
3465    // in1 = "val"
3466    public resultArray7_char reduce_my_array_char(byte[] in1) {
3467        // Verify that "in1" is non-null.
3468        if (in1 == null) {
3469            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3470        }
3471        Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
3472        ain1.setAutoPadding(true);
3473        ain1.copyFrom(in1);
3474
3475        resultArray7_char result = reduce_my_array_char(ain1, null);
3476        result.mTempIns = new Allocation[]{ain1};
3477        return result;
3478    }
3479
3480    // ain1 = "char val"
3481    public resultArray7_char reduce_my_array_char(Allocation ain1) {
3482        return reduce_my_array_char(ain1, null);
3483    }
3484
3485    // ain1 = "char val"
3486    public resultArray7_char reduce_my_array_char(Allocation ain1, Script.LaunchOptions sc) {
3487        // check ain1
3488        if (!ain1.getType().getElement().isCompatible(__I8)) {
3489            throw new RSRuntimeException("Type mismatch with I8!");
3490        }
3491        Allocation aout = Allocation.createSized(mRSLocal, __I8, 7);
3492        aout.setAutoPadding(true);
3493        reduce(mExportReduceIdx_my_array_char, new Allocation[]{ain1}, aout, sc);
3494        return new resultArray7_char(aout);
3495    }
3496
3497    private final static int mExportReduceIdx_my_array_char2 = 22;
3498    // in1 = "val", flattened 2-vectors
3499    public resultArray7_char2 reduce_my_array_char2(byte[] in1) {
3500        // Verify that "in1" is non-null.
3501        if (in1 == null) {
3502            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3503        }
3504        // Verify that the array length is a multiple of the vector size.
3505        if (in1.length % 2 != 0) {
3506            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3507        }
3508        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
3509        ain1.setAutoPadding(true);
3510        ain1.copyFrom(in1);
3511
3512        resultArray7_char2 result = reduce_my_array_char2(ain1, null);
3513        result.mTempIns = new Allocation[]{ain1};
3514        return result;
3515    }
3516
3517    // ain1 = "char2 val"
3518    public resultArray7_char2 reduce_my_array_char2(Allocation ain1) {
3519        return reduce_my_array_char2(ain1, null);
3520    }
3521
3522    // ain1 = "char2 val"
3523    public resultArray7_char2 reduce_my_array_char2(Allocation ain1, Script.LaunchOptions sc) {
3524        // check ain1
3525        if (!ain1.getType().getElement().isCompatible(__I8_2)) {
3526            throw new RSRuntimeException("Type mismatch with I8_2!");
3527        }
3528        Allocation aout = Allocation.createSized(mRSLocal, __I8_2, 7);
3529        aout.setAutoPadding(true);
3530        reduce(mExportReduceIdx_my_array_char2, new Allocation[]{ain1}, aout, sc);
3531        return new resultArray7_char2(aout);
3532    }
3533
3534    private final static int mExportReduceIdx_my_array_char4 = 23;
3535    // in1 = "val", flattened 4-vectors
3536    public resultArray7_char4 reduce_my_array_char4(byte[] in1) {
3537        // Verify that "in1" is non-null.
3538        if (in1 == null) {
3539            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3540        }
3541        // Verify that the array length is a multiple of the vector size.
3542        if (in1.length % 4 != 0) {
3543            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3544        }
3545        Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
3546        ain1.setAutoPadding(true);
3547        ain1.copyFrom(in1);
3548
3549        resultArray7_char4 result = reduce_my_array_char4(ain1, null);
3550        result.mTempIns = new Allocation[]{ain1};
3551        return result;
3552    }
3553
3554    // ain1 = "char4 val"
3555    public resultArray7_char4 reduce_my_array_char4(Allocation ain1) {
3556        return reduce_my_array_char4(ain1, null);
3557    }
3558
3559    // ain1 = "char4 val"
3560    public resultArray7_char4 reduce_my_array_char4(Allocation ain1, Script.LaunchOptions sc) {
3561        // check ain1
3562        if (!ain1.getType().getElement().isCompatible(__I8_4)) {
3563            throw new RSRuntimeException("Type mismatch with I8_4!");
3564        }
3565        Allocation aout = Allocation.createSized(mRSLocal, __I8_4, 7);
3566        aout.setAutoPadding(true);
3567        reduce(mExportReduceIdx_my_array_char4, new Allocation[]{ain1}, aout, sc);
3568        return new resultArray7_char4(aout);
3569    }
3570
3571    private final static int mExportReduceIdx_my_short = 24;
3572    // in1 = "val"
3573    public result_short reduce_my_short(short[] in1) {
3574        // Verify that "in1" is non-null.
3575        if (in1 == null) {
3576            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3577        }
3578        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
3579        ain1.setAutoPadding(true);
3580        ain1.copyFrom(in1);
3581
3582        result_short result = reduce_my_short(ain1, null);
3583        result.mTempIns = new Allocation[]{ain1};
3584        return result;
3585    }
3586
3587    // ain1 = "short val"
3588    public result_short reduce_my_short(Allocation ain1) {
3589        return reduce_my_short(ain1, null);
3590    }
3591
3592    // ain1 = "short val"
3593    public result_short reduce_my_short(Allocation ain1, Script.LaunchOptions sc) {
3594        // check ain1
3595        if (!ain1.getType().getElement().isCompatible(__I16)) {
3596            throw new RSRuntimeException("Type mismatch with I16!");
3597        }
3598        Allocation aout = Allocation.createSized(mRSLocal, __I16, 1);
3599        aout.setAutoPadding(true);
3600        reduce(mExportReduceIdx_my_short, new Allocation[]{ain1}, aout, sc);
3601        return new result_short(aout);
3602    }
3603
3604    private final static int mExportReduceIdx_my_short2 = 25;
3605    // in1 = "val", flattened 2-vectors
3606    public result_short2 reduce_my_short2(short[] in1) {
3607        // Verify that "in1" is non-null.
3608        if (in1 == null) {
3609            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3610        }
3611        // Verify that the array length is a multiple of the vector size.
3612        if (in1.length % 2 != 0) {
3613            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3614        }
3615        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
3616        ain1.setAutoPadding(true);
3617        ain1.copyFrom(in1);
3618
3619        result_short2 result = reduce_my_short2(ain1, null);
3620        result.mTempIns = new Allocation[]{ain1};
3621        return result;
3622    }
3623
3624    // ain1 = "short2 val"
3625    public result_short2 reduce_my_short2(Allocation ain1) {
3626        return reduce_my_short2(ain1, null);
3627    }
3628
3629    // ain1 = "short2 val"
3630    public result_short2 reduce_my_short2(Allocation ain1, Script.LaunchOptions sc) {
3631        // check ain1
3632        if (!ain1.getType().getElement().isCompatible(__I16_2)) {
3633            throw new RSRuntimeException("Type mismatch with I16_2!");
3634        }
3635        Allocation aout = Allocation.createSized(mRSLocal, __I16_2, 1);
3636        aout.setAutoPadding(true);
3637        reduce(mExportReduceIdx_my_short2, new Allocation[]{ain1}, aout, sc);
3638        return new result_short2(aout);
3639    }
3640
3641    private final static int mExportReduceIdx_my_short4 = 26;
3642    // in1 = "val", flattened 4-vectors
3643    public result_short4 reduce_my_short4(short[] in1) {
3644        // Verify that "in1" is non-null.
3645        if (in1 == null) {
3646            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3647        }
3648        // Verify that the array length is a multiple of the vector size.
3649        if (in1.length % 4 != 0) {
3650            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3651        }
3652        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
3653        ain1.setAutoPadding(true);
3654        ain1.copyFrom(in1);
3655
3656        result_short4 result = reduce_my_short4(ain1, null);
3657        result.mTempIns = new Allocation[]{ain1};
3658        return result;
3659    }
3660
3661    // ain1 = "short4 val"
3662    public result_short4 reduce_my_short4(Allocation ain1) {
3663        return reduce_my_short4(ain1, null);
3664    }
3665
3666    // ain1 = "short4 val"
3667    public result_short4 reduce_my_short4(Allocation ain1, Script.LaunchOptions sc) {
3668        // check ain1
3669        if (!ain1.getType().getElement().isCompatible(__I16_4)) {
3670            throw new RSRuntimeException("Type mismatch with I16_4!");
3671        }
3672        Allocation aout = Allocation.createSized(mRSLocal, __I16_4, 1);
3673        aout.setAutoPadding(true);
3674        reduce(mExportReduceIdx_my_short4, new Allocation[]{ain1}, aout, sc);
3675        return new result_short4(aout);
3676    }
3677
3678    private final static int mExportReduceIdx_my_array_short = 27;
3679    // in1 = "val"
3680    public resultArray7_short reduce_my_array_short(short[] in1) {
3681        // Verify that "in1" is non-null.
3682        if (in1 == null) {
3683            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3684        }
3685        Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
3686        ain1.setAutoPadding(true);
3687        ain1.copyFrom(in1);
3688
3689        resultArray7_short result = reduce_my_array_short(ain1, null);
3690        result.mTempIns = new Allocation[]{ain1};
3691        return result;
3692    }
3693
3694    // ain1 = "short val"
3695    public resultArray7_short reduce_my_array_short(Allocation ain1) {
3696        return reduce_my_array_short(ain1, null);
3697    }
3698
3699    // ain1 = "short val"
3700    public resultArray7_short reduce_my_array_short(Allocation ain1, Script.LaunchOptions sc) {
3701        // check ain1
3702        if (!ain1.getType().getElement().isCompatible(__I16)) {
3703            throw new RSRuntimeException("Type mismatch with I16!");
3704        }
3705        Allocation aout = Allocation.createSized(mRSLocal, __I16, 7);
3706        aout.setAutoPadding(true);
3707        reduce(mExportReduceIdx_my_array_short, new Allocation[]{ain1}, aout, sc);
3708        return new resultArray7_short(aout);
3709    }
3710
3711    private final static int mExportReduceIdx_my_array_short2 = 28;
3712    // in1 = "val", flattened 2-vectors
3713    public resultArray7_short2 reduce_my_array_short2(short[] in1) {
3714        // Verify that "in1" is non-null.
3715        if (in1 == null) {
3716            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3717        }
3718        // Verify that the array length is a multiple of the vector size.
3719        if (in1.length % 2 != 0) {
3720            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3721        }
3722        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
3723        ain1.setAutoPadding(true);
3724        ain1.copyFrom(in1);
3725
3726        resultArray7_short2 result = reduce_my_array_short2(ain1, null);
3727        result.mTempIns = new Allocation[]{ain1};
3728        return result;
3729    }
3730
3731    // ain1 = "short2 val"
3732    public resultArray7_short2 reduce_my_array_short2(Allocation ain1) {
3733        return reduce_my_array_short2(ain1, null);
3734    }
3735
3736    // ain1 = "short2 val"
3737    public resultArray7_short2 reduce_my_array_short2(Allocation ain1, Script.LaunchOptions sc) {
3738        // check ain1
3739        if (!ain1.getType().getElement().isCompatible(__I16_2)) {
3740            throw new RSRuntimeException("Type mismatch with I16_2!");
3741        }
3742        Allocation aout = Allocation.createSized(mRSLocal, __I16_2, 7);
3743        aout.setAutoPadding(true);
3744        reduce(mExportReduceIdx_my_array_short2, new Allocation[]{ain1}, aout, sc);
3745        return new resultArray7_short2(aout);
3746    }
3747
3748    private final static int mExportReduceIdx_my_array_short4 = 29;
3749    // in1 = "val", flattened 4-vectors
3750    public resultArray7_short4 reduce_my_array_short4(short[] in1) {
3751        // Verify that "in1" is non-null.
3752        if (in1 == null) {
3753            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3754        }
3755        // Verify that the array length is a multiple of the vector size.
3756        if (in1.length % 4 != 0) {
3757            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3758        }
3759        Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
3760        ain1.setAutoPadding(true);
3761        ain1.copyFrom(in1);
3762
3763        resultArray7_short4 result = reduce_my_array_short4(ain1, null);
3764        result.mTempIns = new Allocation[]{ain1};
3765        return result;
3766    }
3767
3768    // ain1 = "short4 val"
3769    public resultArray7_short4 reduce_my_array_short4(Allocation ain1) {
3770        return reduce_my_array_short4(ain1, null);
3771    }
3772
3773    // ain1 = "short4 val"
3774    public resultArray7_short4 reduce_my_array_short4(Allocation ain1, Script.LaunchOptions sc) {
3775        // check ain1
3776        if (!ain1.getType().getElement().isCompatible(__I16_4)) {
3777            throw new RSRuntimeException("Type mismatch with I16_4!");
3778        }
3779        Allocation aout = Allocation.createSized(mRSLocal, __I16_4, 7);
3780        aout.setAutoPadding(true);
3781        reduce(mExportReduceIdx_my_array_short4, new Allocation[]{ain1}, aout, sc);
3782        return new resultArray7_short4(aout);
3783    }
3784
3785    private final static int mExportReduceIdx_my_int = 30;
3786    // in1 = "val"
3787    public result_int reduce_my_int(int[] in1) {
3788        // Verify that "in1" is non-null.
3789        if (in1 == null) {
3790            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3791        }
3792        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
3793        ain1.setAutoPadding(true);
3794        ain1.copyFrom(in1);
3795
3796        result_int result = reduce_my_int(ain1, null);
3797        result.mTempIns = new Allocation[]{ain1};
3798        return result;
3799    }
3800
3801    // ain1 = "int val"
3802    public result_int reduce_my_int(Allocation ain1) {
3803        return reduce_my_int(ain1, null);
3804    }
3805
3806    // ain1 = "int val"
3807    public result_int reduce_my_int(Allocation ain1, Script.LaunchOptions sc) {
3808        // check ain1
3809        if (!ain1.getType().getElement().isCompatible(__I32)) {
3810            throw new RSRuntimeException("Type mismatch with I32!");
3811        }
3812        Allocation aout = Allocation.createSized(mRSLocal, __I32, 1);
3813        aout.setAutoPadding(true);
3814        reduce(mExportReduceIdx_my_int, new Allocation[]{ain1}, aout, sc);
3815        return new result_int(aout);
3816    }
3817
3818    private final static int mExportReduceIdx_my_int2 = 31;
3819    // in1 = "val", flattened 2-vectors
3820    public result_int2 reduce_my_int2(int[] in1) {
3821        // Verify that "in1" is non-null.
3822        if (in1 == null) {
3823            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3824        }
3825        // Verify that the array length is a multiple of the vector size.
3826        if (in1.length % 2 != 0) {
3827            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3828        }
3829        Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
3830        ain1.setAutoPadding(true);
3831        ain1.copyFrom(in1);
3832
3833        result_int2 result = reduce_my_int2(ain1, null);
3834        result.mTempIns = new Allocation[]{ain1};
3835        return result;
3836    }
3837
3838    // ain1 = "int2 val"
3839    public result_int2 reduce_my_int2(Allocation ain1) {
3840        return reduce_my_int2(ain1, null);
3841    }
3842
3843    // ain1 = "int2 val"
3844    public result_int2 reduce_my_int2(Allocation ain1, Script.LaunchOptions sc) {
3845        // check ain1
3846        if (!ain1.getType().getElement().isCompatible(__I32_2)) {
3847            throw new RSRuntimeException("Type mismatch with I32_2!");
3848        }
3849        Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 1);
3850        aout.setAutoPadding(true);
3851        reduce(mExportReduceIdx_my_int2, new Allocation[]{ain1}, aout, sc);
3852        return new result_int2(aout);
3853    }
3854
3855    private final static int mExportReduceIdx_my_int4 = 32;
3856    // in1 = "val", flattened 4-vectors
3857    public result_int4 reduce_my_int4(int[] in1) {
3858        // Verify that "in1" is non-null.
3859        if (in1 == null) {
3860            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3861        }
3862        // Verify that the array length is a multiple of the vector size.
3863        if (in1.length % 4 != 0) {
3864            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3865        }
3866        Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
3867        ain1.setAutoPadding(true);
3868        ain1.copyFrom(in1);
3869
3870        result_int4 result = reduce_my_int4(ain1, null);
3871        result.mTempIns = new Allocation[]{ain1};
3872        return result;
3873    }
3874
3875    // ain1 = "int4 val"
3876    public result_int4 reduce_my_int4(Allocation ain1) {
3877        return reduce_my_int4(ain1, null);
3878    }
3879
3880    // ain1 = "int4 val"
3881    public result_int4 reduce_my_int4(Allocation ain1, Script.LaunchOptions sc) {
3882        // check ain1
3883        if (!ain1.getType().getElement().isCompatible(__I32_4)) {
3884            throw new RSRuntimeException("Type mismatch with I32_4!");
3885        }
3886        Allocation aout = Allocation.createSized(mRSLocal, __I32_4, 1);
3887        aout.setAutoPadding(true);
3888        reduce(mExportReduceIdx_my_int4, new Allocation[]{ain1}, aout, sc);
3889        return new result_int4(aout);
3890    }
3891
3892    private final static int mExportReduceIdx_my_array_int = 33;
3893    // in1 = "val"
3894    public resultArray7_int reduce_my_array_int(int[] in1) {
3895        // Verify that "in1" is non-null.
3896        if (in1 == null) {
3897            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3898        }
3899        Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
3900        ain1.setAutoPadding(true);
3901        ain1.copyFrom(in1);
3902
3903        resultArray7_int result = reduce_my_array_int(ain1, null);
3904        result.mTempIns = new Allocation[]{ain1};
3905        return result;
3906    }
3907
3908    // ain1 = "int val"
3909    public resultArray7_int reduce_my_array_int(Allocation ain1) {
3910        return reduce_my_array_int(ain1, null);
3911    }
3912
3913    // ain1 = "int val"
3914    public resultArray7_int reduce_my_array_int(Allocation ain1, Script.LaunchOptions sc) {
3915        // check ain1
3916        if (!ain1.getType().getElement().isCompatible(__I32)) {
3917            throw new RSRuntimeException("Type mismatch with I32!");
3918        }
3919        Allocation aout = Allocation.createSized(mRSLocal, __I32, 7);
3920        aout.setAutoPadding(true);
3921        reduce(mExportReduceIdx_my_array_int, new Allocation[]{ain1}, aout, sc);
3922        return new resultArray7_int(aout);
3923    }
3924
3925    private final static int mExportReduceIdx_my_array_int2 = 34;
3926    // in1 = "val", flattened 2-vectors
3927    public resultArray7_int2 reduce_my_array_int2(int[] in1) {
3928        // Verify that "in1" is non-null.
3929        if (in1 == null) {
3930            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3931        }
3932        // Verify that the array length is a multiple of the vector size.
3933        if (in1.length % 2 != 0) {
3934            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
3935        }
3936        Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
3937        ain1.setAutoPadding(true);
3938        ain1.copyFrom(in1);
3939
3940        resultArray7_int2 result = reduce_my_array_int2(ain1, null);
3941        result.mTempIns = new Allocation[]{ain1};
3942        return result;
3943    }
3944
3945    // ain1 = "int2 val"
3946    public resultArray7_int2 reduce_my_array_int2(Allocation ain1) {
3947        return reduce_my_array_int2(ain1, null);
3948    }
3949
3950    // ain1 = "int2 val"
3951    public resultArray7_int2 reduce_my_array_int2(Allocation ain1, Script.LaunchOptions sc) {
3952        // check ain1
3953        if (!ain1.getType().getElement().isCompatible(__I32_2)) {
3954            throw new RSRuntimeException("Type mismatch with I32_2!");
3955        }
3956        Allocation aout = Allocation.createSized(mRSLocal, __I32_2, 7);
3957        aout.setAutoPadding(true);
3958        reduce(mExportReduceIdx_my_array_int2, new Allocation[]{ain1}, aout, sc);
3959        return new resultArray7_int2(aout);
3960    }
3961
3962    private final static int mExportReduceIdx_my_array_int4 = 35;
3963    // in1 = "val", flattened 4-vectors
3964    public resultArray7_int4 reduce_my_array_int4(int[] in1) {
3965        // Verify that "in1" is non-null.
3966        if (in1 == null) {
3967            throw new RSIllegalArgumentException("Array \"in1\" is null!");
3968        }
3969        // Verify that the array length is a multiple of the vector size.
3970        if (in1.length % 4 != 0) {
3971            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3972        }
3973        Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
3974        ain1.setAutoPadding(true);
3975        ain1.copyFrom(in1);
3976
3977        resultArray7_int4 result = reduce_my_array_int4(ain1, null);
3978        result.mTempIns = new Allocation[]{ain1};
3979        return result;
3980    }
3981
3982    // ain1 = "int4 val"
3983    public resultArray7_int4 reduce_my_array_int4(Allocation ain1) {
3984        return reduce_my_array_int4(ain1, null);
3985    }
3986
3987    // ain1 = "int4 val"
3988    public resultArray7_int4 reduce_my_array_int4(Allocation ain1, Script.LaunchOptions sc) {
3989        // check ain1
3990        if (!ain1.getType().getElement().isCompatible(__I32_4)) {
3991            throw new RSRuntimeException("Type mismatch with I32_4!");
3992        }
3993        Allocation aout = Allocation.createSized(mRSLocal, __I32_4, 7);
3994        aout.setAutoPadding(true);
3995        reduce(mExportReduceIdx_my_array_int4, new Allocation[]{ain1}, aout, sc);
3996        return new resultArray7_int4(aout);
3997    }
3998
3999    private final static int mExportReduceIdx_my_long = 36;
4000    // in1 = "val"
4001    public result_long reduce_my_long(long[] in1) {
4002        // Verify that "in1" is non-null.
4003        if (in1 == null) {
4004            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4005        }
4006        Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
4007        ain1.setAutoPadding(true);
4008        ain1.copyFrom(in1);
4009
4010        result_long result = reduce_my_long(ain1, null);
4011        result.mTempIns = new Allocation[]{ain1};
4012        return result;
4013    }
4014
4015    // ain1 = "long val"
4016    public result_long reduce_my_long(Allocation ain1) {
4017        return reduce_my_long(ain1, null);
4018    }
4019
4020    // ain1 = "long val"
4021    public result_long reduce_my_long(Allocation ain1, Script.LaunchOptions sc) {
4022        // check ain1
4023        if (!ain1.getType().getElement().isCompatible(__I64)) {
4024            throw new RSRuntimeException("Type mismatch with I64!");
4025        }
4026        Allocation aout = Allocation.createSized(mRSLocal, __I64, 1);
4027        aout.setAutoPadding(true);
4028        reduce(mExportReduceIdx_my_long, new Allocation[]{ain1}, aout, sc);
4029        return new result_long(aout);
4030    }
4031
4032    private final static int mExportReduceIdx_my_long2 = 37;
4033    // in1 = "val", flattened 2-vectors
4034    public result_long2 reduce_my_long2(long[] in1) {
4035        // Verify that "in1" is non-null.
4036        if (in1 == null) {
4037            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4038        }
4039        // Verify that the array length is a multiple of the vector size.
4040        if (in1.length % 2 != 0) {
4041            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4042        }
4043        Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
4044        ain1.setAutoPadding(true);
4045        ain1.copyFrom(in1);
4046
4047        result_long2 result = reduce_my_long2(ain1, null);
4048        result.mTempIns = new Allocation[]{ain1};
4049        return result;
4050    }
4051
4052    // ain1 = "long2 val"
4053    public result_long2 reduce_my_long2(Allocation ain1) {
4054        return reduce_my_long2(ain1, null);
4055    }
4056
4057    // ain1 = "long2 val"
4058    public result_long2 reduce_my_long2(Allocation ain1, Script.LaunchOptions sc) {
4059        // check ain1
4060        if (!ain1.getType().getElement().isCompatible(__I64_2)) {
4061            throw new RSRuntimeException("Type mismatch with I64_2!");
4062        }
4063        Allocation aout = Allocation.createSized(mRSLocal, __I64_2, 1);
4064        aout.setAutoPadding(true);
4065        reduce(mExportReduceIdx_my_long2, new Allocation[]{ain1}, aout, sc);
4066        return new result_long2(aout);
4067    }
4068
4069    private final static int mExportReduceIdx_my_long4 = 38;
4070    // in1 = "val", flattened 4-vectors
4071    public result_long4 reduce_my_long4(long[] in1) {
4072        // Verify that "in1" is non-null.
4073        if (in1 == null) {
4074            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4075        }
4076        // Verify that the array length is a multiple of the vector size.
4077        if (in1.length % 4 != 0) {
4078            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4079        }
4080        Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
4081        ain1.setAutoPadding(true);
4082        ain1.copyFrom(in1);
4083
4084        result_long4 result = reduce_my_long4(ain1, null);
4085        result.mTempIns = new Allocation[]{ain1};
4086        return result;
4087    }
4088
4089    // ain1 = "long4 val"
4090    public result_long4 reduce_my_long4(Allocation ain1) {
4091        return reduce_my_long4(ain1, null);
4092    }
4093
4094    // ain1 = "long4 val"
4095    public result_long4 reduce_my_long4(Allocation ain1, Script.LaunchOptions sc) {
4096        // check ain1
4097        if (!ain1.getType().getElement().isCompatible(__I64_4)) {
4098            throw new RSRuntimeException("Type mismatch with I64_4!");
4099        }
4100        Allocation aout = Allocation.createSized(mRSLocal, __I64_4, 1);
4101        aout.setAutoPadding(true);
4102        reduce(mExportReduceIdx_my_long4, new Allocation[]{ain1}, aout, sc);
4103        return new result_long4(aout);
4104    }
4105
4106    private final static int mExportReduceIdx_my_array_long = 39;
4107    // in1 = "val"
4108    public resultArray7_long reduce_my_array_long(long[] in1) {
4109        // Verify that "in1" is non-null.
4110        if (in1 == null) {
4111            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4112        }
4113        Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
4114        ain1.setAutoPadding(true);
4115        ain1.copyFrom(in1);
4116
4117        resultArray7_long result = reduce_my_array_long(ain1, null);
4118        result.mTempIns = new Allocation[]{ain1};
4119        return result;
4120    }
4121
4122    // ain1 = "long val"
4123    public resultArray7_long reduce_my_array_long(Allocation ain1) {
4124        return reduce_my_array_long(ain1, null);
4125    }
4126
4127    // ain1 = "long val"
4128    public resultArray7_long reduce_my_array_long(Allocation ain1, Script.LaunchOptions sc) {
4129        // check ain1
4130        if (!ain1.getType().getElement().isCompatible(__I64)) {
4131            throw new RSRuntimeException("Type mismatch with I64!");
4132        }
4133        Allocation aout = Allocation.createSized(mRSLocal, __I64, 7);
4134        aout.setAutoPadding(true);
4135        reduce(mExportReduceIdx_my_array_long, new Allocation[]{ain1}, aout, sc);
4136        return new resultArray7_long(aout);
4137    }
4138
4139    private final static int mExportReduceIdx_my_array_long2 = 40;
4140    // in1 = "val", flattened 2-vectors
4141    public resultArray7_long2 reduce_my_array_long2(long[] in1) {
4142        // Verify that "in1" is non-null.
4143        if (in1 == null) {
4144            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4145        }
4146        // Verify that the array length is a multiple of the vector size.
4147        if (in1.length % 2 != 0) {
4148            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4149        }
4150        Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
4151        ain1.setAutoPadding(true);
4152        ain1.copyFrom(in1);
4153
4154        resultArray7_long2 result = reduce_my_array_long2(ain1, null);
4155        result.mTempIns = new Allocation[]{ain1};
4156        return result;
4157    }
4158
4159    // ain1 = "long2 val"
4160    public resultArray7_long2 reduce_my_array_long2(Allocation ain1) {
4161        return reduce_my_array_long2(ain1, null);
4162    }
4163
4164    // ain1 = "long2 val"
4165    public resultArray7_long2 reduce_my_array_long2(Allocation ain1, Script.LaunchOptions sc) {
4166        // check ain1
4167        if (!ain1.getType().getElement().isCompatible(__I64_2)) {
4168            throw new RSRuntimeException("Type mismatch with I64_2!");
4169        }
4170        Allocation aout = Allocation.createSized(mRSLocal, __I64_2, 7);
4171        aout.setAutoPadding(true);
4172        reduce(mExportReduceIdx_my_array_long2, new Allocation[]{ain1}, aout, sc);
4173        return new resultArray7_long2(aout);
4174    }
4175
4176    private final static int mExportReduceIdx_my_array_long4 = 41;
4177    // in1 = "val", flattened 4-vectors
4178    public resultArray7_long4 reduce_my_array_long4(long[] in1) {
4179        // Verify that "in1" is non-null.
4180        if (in1 == null) {
4181            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4182        }
4183        // Verify that the array length is a multiple of the vector size.
4184        if (in1.length % 4 != 0) {
4185            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4186        }
4187        Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
4188        ain1.setAutoPadding(true);
4189        ain1.copyFrom(in1);
4190
4191        resultArray7_long4 result = reduce_my_array_long4(ain1, null);
4192        result.mTempIns = new Allocation[]{ain1};
4193        return result;
4194    }
4195
4196    // ain1 = "long4 val"
4197    public resultArray7_long4 reduce_my_array_long4(Allocation ain1) {
4198        return reduce_my_array_long4(ain1, null);
4199    }
4200
4201    // ain1 = "long4 val"
4202    public resultArray7_long4 reduce_my_array_long4(Allocation ain1, Script.LaunchOptions sc) {
4203        // check ain1
4204        if (!ain1.getType().getElement().isCompatible(__I64_4)) {
4205            throw new RSRuntimeException("Type mismatch with I64_4!");
4206        }
4207        Allocation aout = Allocation.createSized(mRSLocal, __I64_4, 7);
4208        aout.setAutoPadding(true);
4209        reduce(mExportReduceIdx_my_array_long4, new Allocation[]{ain1}, aout, sc);
4210        return new resultArray7_long4(aout);
4211    }
4212
4213    private final static int mExportReduceIdx_my_uchar = 42;
4214    // in1 = "val"
4215    public result_uchar reduce_my_uchar(byte[] in1) {
4216        // Verify that "in1" is non-null.
4217        if (in1 == null) {
4218            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4219        }
4220        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
4221        ain1.setAutoPadding(true);
4222        ain1.copyFrom(in1);
4223
4224        result_uchar result = reduce_my_uchar(ain1, null);
4225        result.mTempIns = new Allocation[]{ain1};
4226        return result;
4227    }
4228
4229    // ain1 = "uchar val"
4230    public result_uchar reduce_my_uchar(Allocation ain1) {
4231        return reduce_my_uchar(ain1, null);
4232    }
4233
4234    // ain1 = "uchar val"
4235    public result_uchar reduce_my_uchar(Allocation ain1, Script.LaunchOptions sc) {
4236        // check ain1
4237        if (!ain1.getType().getElement().isCompatible(__U8)) {
4238            throw new RSRuntimeException("Type mismatch with U8!");
4239        }
4240        Allocation aout = Allocation.createSized(mRSLocal, __U8, 1);
4241        aout.setAutoPadding(true);
4242        reduce(mExportReduceIdx_my_uchar, new Allocation[]{ain1}, aout, sc);
4243        return new result_uchar(aout);
4244    }
4245
4246    private final static int mExportReduceIdx_my_uchar2 = 43;
4247    // in1 = "val", flattened 2-vectors
4248    public result_uchar2 reduce_my_uchar2(byte[] in1) {
4249        // Verify that "in1" is non-null.
4250        if (in1 == null) {
4251            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4252        }
4253        // Verify that the array length is a multiple of the vector size.
4254        if (in1.length % 2 != 0) {
4255            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4256        }
4257        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
4258        ain1.setAutoPadding(true);
4259        ain1.copyFrom(in1);
4260
4261        result_uchar2 result = reduce_my_uchar2(ain1, null);
4262        result.mTempIns = new Allocation[]{ain1};
4263        return result;
4264    }
4265
4266    // ain1 = "uchar2 val"
4267    public result_uchar2 reduce_my_uchar2(Allocation ain1) {
4268        return reduce_my_uchar2(ain1, null);
4269    }
4270
4271    // ain1 = "uchar2 val"
4272    public result_uchar2 reduce_my_uchar2(Allocation ain1, Script.LaunchOptions sc) {
4273        // check ain1
4274        if (!ain1.getType().getElement().isCompatible(__U8_2)) {
4275            throw new RSRuntimeException("Type mismatch with U8_2!");
4276        }
4277        Allocation aout = Allocation.createSized(mRSLocal, __U8_2, 1);
4278        aout.setAutoPadding(true);
4279        reduce(mExportReduceIdx_my_uchar2, new Allocation[]{ain1}, aout, sc);
4280        return new result_uchar2(aout);
4281    }
4282
4283    private final static int mExportReduceIdx_my_uchar4 = 44;
4284    // in1 = "val", flattened 4-vectors
4285    public result_uchar4 reduce_my_uchar4(byte[] in1) {
4286        // Verify that "in1" is non-null.
4287        if (in1 == null) {
4288            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4289        }
4290        // Verify that the array length is a multiple of the vector size.
4291        if (in1.length % 4 != 0) {
4292            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4293        }
4294        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
4295        ain1.setAutoPadding(true);
4296        ain1.copyFrom(in1);
4297
4298        result_uchar4 result = reduce_my_uchar4(ain1, null);
4299        result.mTempIns = new Allocation[]{ain1};
4300        return result;
4301    }
4302
4303    // ain1 = "uchar4 val"
4304    public result_uchar4 reduce_my_uchar4(Allocation ain1) {
4305        return reduce_my_uchar4(ain1, null);
4306    }
4307
4308    // ain1 = "uchar4 val"
4309    public result_uchar4 reduce_my_uchar4(Allocation ain1, Script.LaunchOptions sc) {
4310        // check ain1
4311        if (!ain1.getType().getElement().isCompatible(__U8_4)) {
4312            throw new RSRuntimeException("Type mismatch with U8_4!");
4313        }
4314        Allocation aout = Allocation.createSized(mRSLocal, __U8_4, 1);
4315        aout.setAutoPadding(true);
4316        reduce(mExportReduceIdx_my_uchar4, new Allocation[]{ain1}, aout, sc);
4317        return new result_uchar4(aout);
4318    }
4319
4320    private final static int mExportReduceIdx_my_array_uchar = 45;
4321    // in1 = "val"
4322    public resultArray7_uchar reduce_my_array_uchar(byte[] in1) {
4323        // Verify that "in1" is non-null.
4324        if (in1 == null) {
4325            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4326        }
4327        Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
4328        ain1.setAutoPadding(true);
4329        ain1.copyFrom(in1);
4330
4331        resultArray7_uchar result = reduce_my_array_uchar(ain1, null);
4332        result.mTempIns = new Allocation[]{ain1};
4333        return result;
4334    }
4335
4336    // ain1 = "uchar val"
4337    public resultArray7_uchar reduce_my_array_uchar(Allocation ain1) {
4338        return reduce_my_array_uchar(ain1, null);
4339    }
4340
4341    // ain1 = "uchar val"
4342    public resultArray7_uchar reduce_my_array_uchar(Allocation ain1, Script.LaunchOptions sc) {
4343        // check ain1
4344        if (!ain1.getType().getElement().isCompatible(__U8)) {
4345            throw new RSRuntimeException("Type mismatch with U8!");
4346        }
4347        Allocation aout = Allocation.createSized(mRSLocal, __U8, 7);
4348        aout.setAutoPadding(true);
4349        reduce(mExportReduceIdx_my_array_uchar, new Allocation[]{ain1}, aout, sc);
4350        return new resultArray7_uchar(aout);
4351    }
4352
4353    private final static int mExportReduceIdx_my_array_uchar2 = 46;
4354    // in1 = "val", flattened 2-vectors
4355    public resultArray7_uchar2 reduce_my_array_uchar2(byte[] in1) {
4356        // Verify that "in1" is non-null.
4357        if (in1 == null) {
4358            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4359        }
4360        // Verify that the array length is a multiple of the vector size.
4361        if (in1.length % 2 != 0) {
4362            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4363        }
4364        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
4365        ain1.setAutoPadding(true);
4366        ain1.copyFrom(in1);
4367
4368        resultArray7_uchar2 result = reduce_my_array_uchar2(ain1, null);
4369        result.mTempIns = new Allocation[]{ain1};
4370        return result;
4371    }
4372
4373    // ain1 = "uchar2 val"
4374    public resultArray7_uchar2 reduce_my_array_uchar2(Allocation ain1) {
4375        return reduce_my_array_uchar2(ain1, null);
4376    }
4377
4378    // ain1 = "uchar2 val"
4379    public resultArray7_uchar2 reduce_my_array_uchar2(Allocation ain1, Script.LaunchOptions sc) {
4380        // check ain1
4381        if (!ain1.getType().getElement().isCompatible(__U8_2)) {
4382            throw new RSRuntimeException("Type mismatch with U8_2!");
4383        }
4384        Allocation aout = Allocation.createSized(mRSLocal, __U8_2, 7);
4385        aout.setAutoPadding(true);
4386        reduce(mExportReduceIdx_my_array_uchar2, new Allocation[]{ain1}, aout, sc);
4387        return new resultArray7_uchar2(aout);
4388    }
4389
4390    private final static int mExportReduceIdx_my_array_uchar4 = 47;
4391    // in1 = "val", flattened 4-vectors
4392    public resultArray7_uchar4 reduce_my_array_uchar4(byte[] in1) {
4393        // Verify that "in1" is non-null.
4394        if (in1 == null) {
4395            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4396        }
4397        // Verify that the array length is a multiple of the vector size.
4398        if (in1.length % 4 != 0) {
4399            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4400        }
4401        Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
4402        ain1.setAutoPadding(true);
4403        ain1.copyFrom(in1);
4404
4405        resultArray7_uchar4 result = reduce_my_array_uchar4(ain1, null);
4406        result.mTempIns = new Allocation[]{ain1};
4407        return result;
4408    }
4409
4410    // ain1 = "uchar4 val"
4411    public resultArray7_uchar4 reduce_my_array_uchar4(Allocation ain1) {
4412        return reduce_my_array_uchar4(ain1, null);
4413    }
4414
4415    // ain1 = "uchar4 val"
4416    public resultArray7_uchar4 reduce_my_array_uchar4(Allocation ain1, Script.LaunchOptions sc) {
4417        // check ain1
4418        if (!ain1.getType().getElement().isCompatible(__U8_4)) {
4419            throw new RSRuntimeException("Type mismatch with U8_4!");
4420        }
4421        Allocation aout = Allocation.createSized(mRSLocal, __U8_4, 7);
4422        aout.setAutoPadding(true);
4423        reduce(mExportReduceIdx_my_array_uchar4, new Allocation[]{ain1}, aout, sc);
4424        return new resultArray7_uchar4(aout);
4425    }
4426
4427    private final static int mExportReduceIdx_my_ushort = 48;
4428    // in1 = "val"
4429    public result_ushort reduce_my_ushort(short[] in1) {
4430        // Verify that "in1" is non-null.
4431        if (in1 == null) {
4432            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4433        }
4434        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
4435        ain1.setAutoPadding(true);
4436        ain1.copyFrom(in1);
4437
4438        result_ushort result = reduce_my_ushort(ain1, null);
4439        result.mTempIns = new Allocation[]{ain1};
4440        return result;
4441    }
4442
4443    // ain1 = "ushort val"
4444    public result_ushort reduce_my_ushort(Allocation ain1) {
4445        return reduce_my_ushort(ain1, null);
4446    }
4447
4448    // ain1 = "ushort val"
4449    public result_ushort reduce_my_ushort(Allocation ain1, Script.LaunchOptions sc) {
4450        // check ain1
4451        if (!ain1.getType().getElement().isCompatible(__U16)) {
4452            throw new RSRuntimeException("Type mismatch with U16!");
4453        }
4454        Allocation aout = Allocation.createSized(mRSLocal, __U16, 1);
4455        aout.setAutoPadding(true);
4456        reduce(mExportReduceIdx_my_ushort, new Allocation[]{ain1}, aout, sc);
4457        return new result_ushort(aout);
4458    }
4459
4460    private final static int mExportReduceIdx_my_ushort2 = 49;
4461    // in1 = "val", flattened 2-vectors
4462    public result_ushort2 reduce_my_ushort2(short[] in1) {
4463        // Verify that "in1" is non-null.
4464        if (in1 == null) {
4465            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4466        }
4467        // Verify that the array length is a multiple of the vector size.
4468        if (in1.length % 2 != 0) {
4469            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4470        }
4471        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
4472        ain1.setAutoPadding(true);
4473        ain1.copyFrom(in1);
4474
4475        result_ushort2 result = reduce_my_ushort2(ain1, null);
4476        result.mTempIns = new Allocation[]{ain1};
4477        return result;
4478    }
4479
4480    // ain1 = "ushort2 val"
4481    public result_ushort2 reduce_my_ushort2(Allocation ain1) {
4482        return reduce_my_ushort2(ain1, null);
4483    }
4484
4485    // ain1 = "ushort2 val"
4486    public result_ushort2 reduce_my_ushort2(Allocation ain1, Script.LaunchOptions sc) {
4487        // check ain1
4488        if (!ain1.getType().getElement().isCompatible(__U16_2)) {
4489            throw new RSRuntimeException("Type mismatch with U16_2!");
4490        }
4491        Allocation aout = Allocation.createSized(mRSLocal, __U16_2, 1);
4492        aout.setAutoPadding(true);
4493        reduce(mExportReduceIdx_my_ushort2, new Allocation[]{ain1}, aout, sc);
4494        return new result_ushort2(aout);
4495    }
4496
4497    private final static int mExportReduceIdx_my_ushort4 = 50;
4498    // in1 = "val", flattened 4-vectors
4499    public result_ushort4 reduce_my_ushort4(short[] in1) {
4500        // Verify that "in1" is non-null.
4501        if (in1 == null) {
4502            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4503        }
4504        // Verify that the array length is a multiple of the vector size.
4505        if (in1.length % 4 != 0) {
4506            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4507        }
4508        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
4509        ain1.setAutoPadding(true);
4510        ain1.copyFrom(in1);
4511
4512        result_ushort4 result = reduce_my_ushort4(ain1, null);
4513        result.mTempIns = new Allocation[]{ain1};
4514        return result;
4515    }
4516
4517    // ain1 = "ushort4 val"
4518    public result_ushort4 reduce_my_ushort4(Allocation ain1) {
4519        return reduce_my_ushort4(ain1, null);
4520    }
4521
4522    // ain1 = "ushort4 val"
4523    public result_ushort4 reduce_my_ushort4(Allocation ain1, Script.LaunchOptions sc) {
4524        // check ain1
4525        if (!ain1.getType().getElement().isCompatible(__U16_4)) {
4526            throw new RSRuntimeException("Type mismatch with U16_4!");
4527        }
4528        Allocation aout = Allocation.createSized(mRSLocal, __U16_4, 1);
4529        aout.setAutoPadding(true);
4530        reduce(mExportReduceIdx_my_ushort4, new Allocation[]{ain1}, aout, sc);
4531        return new result_ushort4(aout);
4532    }
4533
4534    private final static int mExportReduceIdx_my_array_ushort = 51;
4535    // in1 = "val"
4536    public resultArray7_ushort reduce_my_array_ushort(short[] in1) {
4537        // Verify that "in1" is non-null.
4538        if (in1 == null) {
4539            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4540        }
4541        Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
4542        ain1.setAutoPadding(true);
4543        ain1.copyFrom(in1);
4544
4545        resultArray7_ushort result = reduce_my_array_ushort(ain1, null);
4546        result.mTempIns = new Allocation[]{ain1};
4547        return result;
4548    }
4549
4550    // ain1 = "ushort val"
4551    public resultArray7_ushort reduce_my_array_ushort(Allocation ain1) {
4552        return reduce_my_array_ushort(ain1, null);
4553    }
4554
4555    // ain1 = "ushort val"
4556    public resultArray7_ushort reduce_my_array_ushort(Allocation ain1, Script.LaunchOptions sc) {
4557        // check ain1
4558        if (!ain1.getType().getElement().isCompatible(__U16)) {
4559            throw new RSRuntimeException("Type mismatch with U16!");
4560        }
4561        Allocation aout = Allocation.createSized(mRSLocal, __U16, 7);
4562        aout.setAutoPadding(true);
4563        reduce(mExportReduceIdx_my_array_ushort, new Allocation[]{ain1}, aout, sc);
4564        return new resultArray7_ushort(aout);
4565    }
4566
4567    private final static int mExportReduceIdx_my_array_ushort2 = 52;
4568    // in1 = "val", flattened 2-vectors
4569    public resultArray7_ushort2 reduce_my_array_ushort2(short[] in1) {
4570        // Verify that "in1" is non-null.
4571        if (in1 == null) {
4572            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4573        }
4574        // Verify that the array length is a multiple of the vector size.
4575        if (in1.length % 2 != 0) {
4576            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4577        }
4578        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
4579        ain1.setAutoPadding(true);
4580        ain1.copyFrom(in1);
4581
4582        resultArray7_ushort2 result = reduce_my_array_ushort2(ain1, null);
4583        result.mTempIns = new Allocation[]{ain1};
4584        return result;
4585    }
4586
4587    // ain1 = "ushort2 val"
4588    public resultArray7_ushort2 reduce_my_array_ushort2(Allocation ain1) {
4589        return reduce_my_array_ushort2(ain1, null);
4590    }
4591
4592    // ain1 = "ushort2 val"
4593    public resultArray7_ushort2 reduce_my_array_ushort2(Allocation ain1, Script.LaunchOptions sc) {
4594        // check ain1
4595        if (!ain1.getType().getElement().isCompatible(__U16_2)) {
4596            throw new RSRuntimeException("Type mismatch with U16_2!");
4597        }
4598        Allocation aout = Allocation.createSized(mRSLocal, __U16_2, 7);
4599        aout.setAutoPadding(true);
4600        reduce(mExportReduceIdx_my_array_ushort2, new Allocation[]{ain1}, aout, sc);
4601        return new resultArray7_ushort2(aout);
4602    }
4603
4604    private final static int mExportReduceIdx_my_array_ushort4 = 53;
4605    // in1 = "val", flattened 4-vectors
4606    public resultArray7_ushort4 reduce_my_array_ushort4(short[] in1) {
4607        // Verify that "in1" is non-null.
4608        if (in1 == null) {
4609            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4610        }
4611        // Verify that the array length is a multiple of the vector size.
4612        if (in1.length % 4 != 0) {
4613            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4614        }
4615        Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
4616        ain1.setAutoPadding(true);
4617        ain1.copyFrom(in1);
4618
4619        resultArray7_ushort4 result = reduce_my_array_ushort4(ain1, null);
4620        result.mTempIns = new Allocation[]{ain1};
4621        return result;
4622    }
4623
4624    // ain1 = "ushort4 val"
4625    public resultArray7_ushort4 reduce_my_array_ushort4(Allocation ain1) {
4626        return reduce_my_array_ushort4(ain1, null);
4627    }
4628
4629    // ain1 = "ushort4 val"
4630    public resultArray7_ushort4 reduce_my_array_ushort4(Allocation ain1, Script.LaunchOptions sc) {
4631        // check ain1
4632        if (!ain1.getType().getElement().isCompatible(__U16_4)) {
4633            throw new RSRuntimeException("Type mismatch with U16_4!");
4634        }
4635        Allocation aout = Allocation.createSized(mRSLocal, __U16_4, 7);
4636        aout.setAutoPadding(true);
4637        reduce(mExportReduceIdx_my_array_ushort4, new Allocation[]{ain1}, aout, sc);
4638        return new resultArray7_ushort4(aout);
4639    }
4640
4641    private final static int mExportReduceIdx_my_uint = 54;
4642    // in1 = "val"
4643    public result_uint reduce_my_uint(int[] in1) {
4644        // Verify that "in1" is non-null.
4645        if (in1 == null) {
4646            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4647        }
4648        Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
4649        ain1.setAutoPadding(true);
4650        ain1.copyFrom(in1);
4651
4652        result_uint result = reduce_my_uint(ain1, null);
4653        result.mTempIns = new Allocation[]{ain1};
4654        return result;
4655    }
4656
4657    // ain1 = "uint val"
4658    public result_uint reduce_my_uint(Allocation ain1) {
4659        return reduce_my_uint(ain1, null);
4660    }
4661
4662    // ain1 = "uint val"
4663    public result_uint reduce_my_uint(Allocation ain1, Script.LaunchOptions sc) {
4664        // check ain1
4665        if (!ain1.getType().getElement().isCompatible(__U32)) {
4666            throw new RSRuntimeException("Type mismatch with U32!");
4667        }
4668        Allocation aout = Allocation.createSized(mRSLocal, __U32, 1);
4669        aout.setAutoPadding(true);
4670        reduce(mExportReduceIdx_my_uint, new Allocation[]{ain1}, aout, sc);
4671        return new result_uint(aout);
4672    }
4673
4674    private final static int mExportReduceIdx_my_uint2 = 55;
4675    // in1 = "val", flattened 2-vectors
4676    public result_uint2 reduce_my_uint2(int[] in1) {
4677        // Verify that "in1" is non-null.
4678        if (in1 == null) {
4679            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4680        }
4681        // Verify that the array length is a multiple of the vector size.
4682        if (in1.length % 2 != 0) {
4683            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4684        }
4685        Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
4686        ain1.setAutoPadding(true);
4687        ain1.copyFrom(in1);
4688
4689        result_uint2 result = reduce_my_uint2(ain1, null);
4690        result.mTempIns = new Allocation[]{ain1};
4691        return result;
4692    }
4693
4694    // ain1 = "uint2 val"
4695    public result_uint2 reduce_my_uint2(Allocation ain1) {
4696        return reduce_my_uint2(ain1, null);
4697    }
4698
4699    // ain1 = "uint2 val"
4700    public result_uint2 reduce_my_uint2(Allocation ain1, Script.LaunchOptions sc) {
4701        // check ain1
4702        if (!ain1.getType().getElement().isCompatible(__U32_2)) {
4703            throw new RSRuntimeException("Type mismatch with U32_2!");
4704        }
4705        Allocation aout = Allocation.createSized(mRSLocal, __U32_2, 1);
4706        aout.setAutoPadding(true);
4707        reduce(mExportReduceIdx_my_uint2, new Allocation[]{ain1}, aout, sc);
4708        return new result_uint2(aout);
4709    }
4710
4711    private final static int mExportReduceIdx_my_uint4 = 56;
4712    // in1 = "val", flattened 4-vectors
4713    public result_uint4 reduce_my_uint4(int[] in1) {
4714        // Verify that "in1" is non-null.
4715        if (in1 == null) {
4716            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4717        }
4718        // Verify that the array length is a multiple of the vector size.
4719        if (in1.length % 4 != 0) {
4720            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4721        }
4722        Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
4723        ain1.setAutoPadding(true);
4724        ain1.copyFrom(in1);
4725
4726        result_uint4 result = reduce_my_uint4(ain1, null);
4727        result.mTempIns = new Allocation[]{ain1};
4728        return result;
4729    }
4730
4731    // ain1 = "uint4 val"
4732    public result_uint4 reduce_my_uint4(Allocation ain1) {
4733        return reduce_my_uint4(ain1, null);
4734    }
4735
4736    // ain1 = "uint4 val"
4737    public result_uint4 reduce_my_uint4(Allocation ain1, Script.LaunchOptions sc) {
4738        // check ain1
4739        if (!ain1.getType().getElement().isCompatible(__U32_4)) {
4740            throw new RSRuntimeException("Type mismatch with U32_4!");
4741        }
4742        Allocation aout = Allocation.createSized(mRSLocal, __U32_4, 1);
4743        aout.setAutoPadding(true);
4744        reduce(mExportReduceIdx_my_uint4, new Allocation[]{ain1}, aout, sc);
4745        return new result_uint4(aout);
4746    }
4747
4748    private final static int mExportReduceIdx_my_array_uint = 57;
4749    // in1 = "val"
4750    public resultArray7_uint reduce_my_array_uint(int[] in1) {
4751        // Verify that "in1" is non-null.
4752        if (in1 == null) {
4753            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4754        }
4755        Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
4756        ain1.setAutoPadding(true);
4757        ain1.copyFrom(in1);
4758
4759        resultArray7_uint result = reduce_my_array_uint(ain1, null);
4760        result.mTempIns = new Allocation[]{ain1};
4761        return result;
4762    }
4763
4764    // ain1 = "uint val"
4765    public resultArray7_uint reduce_my_array_uint(Allocation ain1) {
4766        return reduce_my_array_uint(ain1, null);
4767    }
4768
4769    // ain1 = "uint val"
4770    public resultArray7_uint reduce_my_array_uint(Allocation ain1, Script.LaunchOptions sc) {
4771        // check ain1
4772        if (!ain1.getType().getElement().isCompatible(__U32)) {
4773            throw new RSRuntimeException("Type mismatch with U32!");
4774        }
4775        Allocation aout = Allocation.createSized(mRSLocal, __U32, 7);
4776        aout.setAutoPadding(true);
4777        reduce(mExportReduceIdx_my_array_uint, new Allocation[]{ain1}, aout, sc);
4778        return new resultArray7_uint(aout);
4779    }
4780
4781    private final static int mExportReduceIdx_my_array_uint2 = 58;
4782    // in1 = "val", flattened 2-vectors
4783    public resultArray7_uint2 reduce_my_array_uint2(int[] in1) {
4784        // Verify that "in1" is non-null.
4785        if (in1 == null) {
4786            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4787        }
4788        // Verify that the array length is a multiple of the vector size.
4789        if (in1.length % 2 != 0) {
4790            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4791        }
4792        Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
4793        ain1.setAutoPadding(true);
4794        ain1.copyFrom(in1);
4795
4796        resultArray7_uint2 result = reduce_my_array_uint2(ain1, null);
4797        result.mTempIns = new Allocation[]{ain1};
4798        return result;
4799    }
4800
4801    // ain1 = "uint2 val"
4802    public resultArray7_uint2 reduce_my_array_uint2(Allocation ain1) {
4803        return reduce_my_array_uint2(ain1, null);
4804    }
4805
4806    // ain1 = "uint2 val"
4807    public resultArray7_uint2 reduce_my_array_uint2(Allocation ain1, Script.LaunchOptions sc) {
4808        // check ain1
4809        if (!ain1.getType().getElement().isCompatible(__U32_2)) {
4810            throw new RSRuntimeException("Type mismatch with U32_2!");
4811        }
4812        Allocation aout = Allocation.createSized(mRSLocal, __U32_2, 7);
4813        aout.setAutoPadding(true);
4814        reduce(mExportReduceIdx_my_array_uint2, new Allocation[]{ain1}, aout, sc);
4815        return new resultArray7_uint2(aout);
4816    }
4817
4818    private final static int mExportReduceIdx_my_array_uint4 = 59;
4819    // in1 = "val", flattened 4-vectors
4820    public resultArray7_uint4 reduce_my_array_uint4(int[] in1) {
4821        // Verify that "in1" is non-null.
4822        if (in1 == null) {
4823            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4824        }
4825        // Verify that the array length is a multiple of the vector size.
4826        if (in1.length % 4 != 0) {
4827            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4828        }
4829        Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
4830        ain1.setAutoPadding(true);
4831        ain1.copyFrom(in1);
4832
4833        resultArray7_uint4 result = reduce_my_array_uint4(ain1, null);
4834        result.mTempIns = new Allocation[]{ain1};
4835        return result;
4836    }
4837
4838    // ain1 = "uint4 val"
4839    public resultArray7_uint4 reduce_my_array_uint4(Allocation ain1) {
4840        return reduce_my_array_uint4(ain1, null);
4841    }
4842
4843    // ain1 = "uint4 val"
4844    public resultArray7_uint4 reduce_my_array_uint4(Allocation ain1, Script.LaunchOptions sc) {
4845        // check ain1
4846        if (!ain1.getType().getElement().isCompatible(__U32_4)) {
4847            throw new RSRuntimeException("Type mismatch with U32_4!");
4848        }
4849        Allocation aout = Allocation.createSized(mRSLocal, __U32_4, 7);
4850        aout.setAutoPadding(true);
4851        reduce(mExportReduceIdx_my_array_uint4, new Allocation[]{ain1}, aout, sc);
4852        return new resultArray7_uint4(aout);
4853    }
4854
4855    private final static int mExportReduceIdx_my_ulong = 60;
4856    // in1 = "val"
4857    public result_ulong reduce_my_ulong(long[] in1) {
4858        // Verify that "in1" is non-null.
4859        if (in1 == null) {
4860            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4861        }
4862        Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
4863        ain1.setAutoPadding(true);
4864        ain1.copyFrom(in1);
4865
4866        result_ulong result = reduce_my_ulong(ain1, null);
4867        result.mTempIns = new Allocation[]{ain1};
4868        return result;
4869    }
4870
4871    // ain1 = "ulong val"
4872    public result_ulong reduce_my_ulong(Allocation ain1) {
4873        return reduce_my_ulong(ain1, null);
4874    }
4875
4876    // ain1 = "ulong val"
4877    public result_ulong reduce_my_ulong(Allocation ain1, Script.LaunchOptions sc) {
4878        // check ain1
4879        if (!ain1.getType().getElement().isCompatible(__U64)) {
4880            throw new RSRuntimeException("Type mismatch with U64!");
4881        }
4882        Allocation aout = Allocation.createSized(mRSLocal, __U64, 1);
4883        aout.setAutoPadding(true);
4884        reduce(mExportReduceIdx_my_ulong, new Allocation[]{ain1}, aout, sc);
4885        return new result_ulong(aout);
4886    }
4887
4888    private final static int mExportReduceIdx_my_ulong2 = 61;
4889    // in1 = "val", flattened 2-vectors
4890    public result_ulong2 reduce_my_ulong2(long[] in1) {
4891        // Verify that "in1" is non-null.
4892        if (in1 == null) {
4893            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4894        }
4895        // Verify that the array length is a multiple of the vector size.
4896        if (in1.length % 2 != 0) {
4897            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4898        }
4899        Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
4900        ain1.setAutoPadding(true);
4901        ain1.copyFrom(in1);
4902
4903        result_ulong2 result = reduce_my_ulong2(ain1, null);
4904        result.mTempIns = new Allocation[]{ain1};
4905        return result;
4906    }
4907
4908    // ain1 = "ulong2 val"
4909    public result_ulong2 reduce_my_ulong2(Allocation ain1) {
4910        return reduce_my_ulong2(ain1, null);
4911    }
4912
4913    // ain1 = "ulong2 val"
4914    public result_ulong2 reduce_my_ulong2(Allocation ain1, Script.LaunchOptions sc) {
4915        // check ain1
4916        if (!ain1.getType().getElement().isCompatible(__U64_2)) {
4917            throw new RSRuntimeException("Type mismatch with U64_2!");
4918        }
4919        Allocation aout = Allocation.createSized(mRSLocal, __U64_2, 1);
4920        aout.setAutoPadding(true);
4921        reduce(mExportReduceIdx_my_ulong2, new Allocation[]{ain1}, aout, sc);
4922        return new result_ulong2(aout);
4923    }
4924
4925    private final static int mExportReduceIdx_my_ulong4 = 62;
4926    // in1 = "val", flattened 4-vectors
4927    public result_ulong4 reduce_my_ulong4(long[] in1) {
4928        // Verify that "in1" is non-null.
4929        if (in1 == null) {
4930            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4931        }
4932        // Verify that the array length is a multiple of the vector size.
4933        if (in1.length % 4 != 0) {
4934            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4935        }
4936        Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
4937        ain1.setAutoPadding(true);
4938        ain1.copyFrom(in1);
4939
4940        result_ulong4 result = reduce_my_ulong4(ain1, null);
4941        result.mTempIns = new Allocation[]{ain1};
4942        return result;
4943    }
4944
4945    // ain1 = "ulong4 val"
4946    public result_ulong4 reduce_my_ulong4(Allocation ain1) {
4947        return reduce_my_ulong4(ain1, null);
4948    }
4949
4950    // ain1 = "ulong4 val"
4951    public result_ulong4 reduce_my_ulong4(Allocation ain1, Script.LaunchOptions sc) {
4952        // check ain1
4953        if (!ain1.getType().getElement().isCompatible(__U64_4)) {
4954            throw new RSRuntimeException("Type mismatch with U64_4!");
4955        }
4956        Allocation aout = Allocation.createSized(mRSLocal, __U64_4, 1);
4957        aout.setAutoPadding(true);
4958        reduce(mExportReduceIdx_my_ulong4, new Allocation[]{ain1}, aout, sc);
4959        return new result_ulong4(aout);
4960    }
4961
4962    private final static int mExportReduceIdx_my_array_ulong = 63;
4963    // in1 = "val"
4964    public resultArray7_ulong reduce_my_array_ulong(long[] in1) {
4965        // Verify that "in1" is non-null.
4966        if (in1 == null) {
4967            throw new RSIllegalArgumentException("Array \"in1\" is null!");
4968        }
4969        Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
4970        ain1.setAutoPadding(true);
4971        ain1.copyFrom(in1);
4972
4973        resultArray7_ulong result = reduce_my_array_ulong(ain1, null);
4974        result.mTempIns = new Allocation[]{ain1};
4975        return result;
4976    }
4977
4978    // ain1 = "ulong val"
4979    public resultArray7_ulong reduce_my_array_ulong(Allocation ain1) {
4980        return reduce_my_array_ulong(ain1, null);
4981    }
4982
4983    // ain1 = "ulong val"
4984    public resultArray7_ulong reduce_my_array_ulong(Allocation ain1, Script.LaunchOptions sc) {
4985        // check ain1
4986        if (!ain1.getType().getElement().isCompatible(__U64)) {
4987            throw new RSRuntimeException("Type mismatch with U64!");
4988        }
4989        Allocation aout = Allocation.createSized(mRSLocal, __U64, 7);
4990        aout.setAutoPadding(true);
4991        reduce(mExportReduceIdx_my_array_ulong, new Allocation[]{ain1}, aout, sc);
4992        return new resultArray7_ulong(aout);
4993    }
4994
4995    private final static int mExportReduceIdx_my_array_ulong2 = 64;
4996    // in1 = "val", flattened 2-vectors
4997    public resultArray7_ulong2 reduce_my_array_ulong2(long[] in1) {
4998        // Verify that "in1" is non-null.
4999        if (in1 == null) {
5000            throw new RSIllegalArgumentException("Array \"in1\" is null!");
5001        }
5002        // Verify that the array length is a multiple of the vector size.
5003        if (in1.length % 2 != 0) {
5004            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
5005        }
5006        Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
5007        ain1.setAutoPadding(true);
5008        ain1.copyFrom(in1);
5009
5010        resultArray7_ulong2 result = reduce_my_array_ulong2(ain1, null);
5011        result.mTempIns = new Allocation[]{ain1};
5012        return result;
5013    }
5014
5015    // ain1 = "ulong2 val"
5016    public resultArray7_ulong2 reduce_my_array_ulong2(Allocation ain1) {
5017        return reduce_my_array_ulong2(ain1, null);
5018    }
5019
5020    // ain1 = "ulong2 val"
5021    public resultArray7_ulong2 reduce_my_array_ulong2(Allocation ain1, Script.LaunchOptions sc) {
5022        // check ain1
5023        if (!ain1.getType().getElement().isCompatible(__U64_2)) {
5024            throw new RSRuntimeException("Type mismatch with U64_2!");
5025        }
5026        Allocation aout = Allocation.createSized(mRSLocal, __U64_2, 7);
5027        aout.setAutoPadding(true);
5028        reduce(mExportReduceIdx_my_array_ulong2, new Allocation[]{ain1}, aout, sc);
5029        return new resultArray7_ulong2(aout);
5030    }
5031
5032    private final static int mExportReduceIdx_my_array_ulong4 = 65;
5033    // in1 = "val", flattened 4-vectors
5034    public resultArray7_ulong4 reduce_my_array_ulong4(long[] in1) {
5035        // Verify that "in1" is non-null.
5036        if (in1 == null) {
5037            throw new RSIllegalArgumentException("Array \"in1\" is null!");
5038        }
5039        // Verify that the array length is a multiple of the vector size.
5040        if (in1.length % 4 != 0) {
5041            throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5042        }
5043        Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
5044        ain1.setAutoPadding(true);
5045        ain1.copyFrom(in1);
5046
5047        resultArray7_ulong4 result = reduce_my_array_ulong4(ain1, null);
5048        result.mTempIns = new Allocation[]{ain1};
5049        return result;
5050    }
5051
5052    // ain1 = "ulong4 val"
5053    public resultArray7_ulong4 reduce_my_array_ulong4(Allocation ain1) {
5054        return reduce_my_array_ulong4(ain1, null);
5055    }
5056
5057    // ain1 = "ulong4 val"
5058    public resultArray7_ulong4 reduce_my_array_ulong4(Allocation ain1, Script.LaunchOptions sc) {
5059        // check ain1
5060        if (!ain1.getType().getElement().isCompatible(__U64_4)) {
5061            throw new RSRuntimeException("Type mismatch with U64_4!");
5062        }
5063        Allocation aout = Allocation.createSized(mRSLocal, __U64_4, 7);
5064        aout.setAutoPadding(true);
5065        reduce(mExportReduceIdx_my_array_ulong4, new Allocation[]{ain1}, aout, sc);
5066        return new resultArray7_ulong4(aout);
5067    }
5068
5069    private final static int mExportReduceIdx_my_bool = 66;
5070    // in1 = "val"
5071    public result_bool reduce_my_bool(byte[] in1) {
5072        // Verify that "in1" is non-null.
5073        if (in1 == null) {
5074            throw new RSIllegalArgumentException("Array \"in1\" is null!");
5075        }
5076        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
5077        ain1.setAutoPadding(true);
5078        ain1.copyFrom(in1);
5079
5080        result_bool result = reduce_my_bool(ain1, null);
5081        result.mTempIns = new Allocation[]{ain1};
5082        return result;
5083    }
5084
5085    // ain1 = "bool val"
5086    public result_bool reduce_my_bool(Allocation ain1) {
5087        return reduce_my_bool(ain1, null);
5088    }
5089
5090    // ain1 = "bool val"
5091    public result_bool reduce_my_bool(Allocation ain1, Script.LaunchOptions sc) {
5092        // check ain1
5093        if (!ain1.getType().getElement().isCompatible(__BOOLEAN)) {
5094            throw new RSRuntimeException("Type mismatch with BOOLEAN!");
5095        }
5096        Allocation aout = Allocation.createSized(mRSLocal, __BOOLEAN, 1);
5097        aout.setAutoPadding(true);
5098        reduce(mExportReduceIdx_my_bool, new Allocation[]{ain1}, aout, sc);
5099        return new result_bool(aout);
5100    }
5101
5102    private final static int mExportReduceIdx_my_array_bool = 67;
5103    // in1 = "val"
5104    public resultArray7_bool reduce_my_array_bool(byte[] in1) {
5105        // Verify that "in1" is non-null.
5106        if (in1 == null) {
5107            throw new RSIllegalArgumentException("Array \"in1\" is null!");
5108        }
5109        Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
5110        ain1.setAutoPadding(true);
5111        ain1.copyFrom(in1);
5112
5113        resultArray7_bool result = reduce_my_array_bool(ain1, null);
5114        result.mTempIns = new Allocation[]{ain1};
5115        return result;
5116    }
5117
5118    // ain1 = "bool val"
5119    public resultArray7_bool reduce_my_array_bool(Allocation ain1) {
5120        return reduce_my_array_bool(ain1, null);
5121    }
5122
5123    // ain1 = "bool val"
5124    public resultArray7_bool reduce_my_array_bool(Allocation ain1, Script.LaunchOptions sc) {
5125        // check ain1
5126        if (!ain1.getType().getElement().isCompatible(__BOOLEAN)) {
5127            throw new RSRuntimeException("Type mismatch with BOOLEAN!");
5128        }
5129        Allocation aout = Allocation.createSized(mRSLocal, __BOOLEAN, 7);
5130        aout.setAutoPadding(true);
5131        reduce(mExportReduceIdx_my_array_bool, new Allocation[]{ain1}, aout, sc);
5132        return new resultArray7_bool(aout);
5133    }
5134
5135}
5136
5137