Cross Reference: /frameworks/compile/slang/tests/P_reduce_general_input/ScriptC_reduce_general

Lines Matching refs:in1
149     // in1 = "in"
150     public result_int reduce_my_half_0(short[] in1) {
151         // Verify that "in1" is non-null.
152         if (in1 == null) {
153             throw new RSIllegalArgumentException("Array \"in1\" is null!");
155         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
157         ain1.copyFrom(in1);
182     // in1 = "in"
183     public result_int reduce_my_half_1(short[] in1) {
184         // Verify that "in1" is non-null.
185         if (in1 == null) {
186             throw new RSIllegalArgumentException("Array \"in1\" is null!");
188         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
190         ain1.copyFrom(in1);
215     // in1 = "in"
216     public result_int reduce_my_half_2(short[] in1) {
217         // Verify that "in1" is non-null.
218         if (in1 == null) {
219             throw new RSIllegalArgumentException("Array \"in1\" is null!");
221         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
223         ain1.copyFrom(in1);
248     // in1 = "in"
249     public result_int reduce_my_half_3(short[] in1) {
250         // Verify that "in1" is non-null.
251         if (in1 == null) {
252             throw new RSIllegalArgumentException("Array \"in1\" is null!");
254         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
256         ain1.copyFrom(in1);
281     // in1 = "in"
282     public result_int reduce_my_half_4(short[] in1) {
283         // Verify that "in1" is non-null.
284         if (in1 == null) {
285             throw new RSIllegalArgumentException("Array \"in1\" is null!");
287         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
289         ain1.copyFrom(in1);
314     // in1 = "in"
315     public result_int reduce_my_half_5(short[] in1) {
316         // Verify that "in1" is non-null.
317         if (in1 == null) {
318             throw new RSIllegalArgumentException("Array \"in1\" is null!");
320         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
322         ain1.copyFrom(in1);
347     // in1 = "in"
348     public result_int reduce_my_half_6(short[] in1) {
349         // Verify that "in1" is non-null.
350         if (in1 == null) {
351             throw new RSIllegalArgumentException("Array \"in1\" is null!");
353         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
355         ain1.copyFrom(in1);
380     // in1 = "in"
381     public result_int reduce_my_half_7(short[] in1) {
382         // Verify that "in1" is non-null.
383         if (in1 == null) {
384             throw new RSIllegalArgumentException("Array \"in1\" is null!");
386         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
388         ain1.copyFrom(in1);
413     // in1 = "in"
414     public result_int reduce_my_half_8(short[] in1) {
415         // Verify that "in1" is non-null.
416         if (in1 == null) {
417             throw new RSIllegalArgumentException("Array \"in1\" is null!");
419         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
421         ain1.copyFrom(in1);
446     // in1 = "in"
447     public result_int reduce_my_half_9(short[] in1) {
448         // Verify that "in1" is non-null.
449         if (in1 == null) {
450             throw new RSIllegalArgumentException("Array \"in1\" is null!");
452         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
454         ain1.copyFrom(in1);
479     // in1 = "in"
480     public result_int reduce_my_half_10(short[] in1) {
481         // Verify that "in1" is non-null.
482         if (in1 == null) {
483             throw new RSIllegalArgumentException("Array \"in1\" is null!");
485         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
487         ain1.copyFrom(in1);
512     // in1 = "in"
513     public result_int reduce_my_half_11(short[] in1) {
514         // Verify that "in1" is non-null.
515         if (in1 == null) {
516             throw new RSIllegalArgumentException("Array \"in1\" is null!");
518         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
520         ain1.copyFrom(in1);
545     // in1 = "in"
546     public result_int reduce_my_half_12(short[] in1) {
547         // Verify that "in1" is non-null.
548         if (in1 == null) {
549             throw new RSIllegalArgumentException("Array \"in1\" is null!");
551         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
553         ain1.copyFrom(in1);
578     // in1 = "in"
579     public result_int reduce_my_half_13(short[] in1) {
580         // Verify that "in1" is non-null.
581         if (in1 == null) {
582             throw new RSIllegalArgumentException("Array \"in1\" is null!");
584         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
586         ain1.copyFrom(in1);
611     // in1 = "in"
612     public result_int reduce_my_half_14(short[] in1) {
613         // Verify that "in1" is non-null.
614         if (in1 == null) {
615             throw new RSIllegalArgumentException("Array \"in1\" is null!");
617         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
619         ain1.copyFrom(in1);
644     // in1 = "in"
645     public result_int reduce_my_half_15(short[] in1) {
646         // Verify that "in1" is non-null.
647         if (in1 == null) {
648             throw new RSIllegalArgumentException("Array \"in1\" is null!");
650         Allocation ain1 = Allocation.createSized(mRSLocal, __F16, in1.length);
652         ain1.copyFrom(in1);
677     // in1 = "in", flattened 2-vectors
678     public result_int reduce_my_half2_0(short[] in1) {
679         // Verify that "in1" is non-null.
680         if (in1 == null) {
681             throw new RSIllegalArgumentException("Array \"in1\" is null!");
684         if (in1.length % 2 != 0) {
685             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
687         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
689         ain1.copyFrom(in1);
714     // in1 = "in", flattened 2-vectors
715     public result_int reduce_my_half2_1(short[] in1) {
716         // Verify that "in1" is non-null.
717         if (in1 == null) {
718             throw new RSIllegalArgumentException("Array \"in1\" is null!");
721         if (in1.length % 2 != 0) {
722             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
724         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
726         ain1.copyFrom(in1);
751     // in1 = "in", flattened 2-vectors
752     public result_int reduce_my_half2_2(short[] in1) {
753         // Verify that "in1" is non-null.
754         if (in1 == null) {
755             throw new RSIllegalArgumentException("Array \"in1\" is null!");
758         if (in1.length % 2 != 0) {
759             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
761         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
763         ain1.copyFrom(in1);
788     // in1 = "in", flattened 2-vectors
789     public result_int reduce_my_half2_3(short[] in1) {
790         // Verify that "in1" is non-null.
791         if (in1 == null) {
792             throw new RSIllegalArgumentException("Array \"in1\" is null!");
795         if (in1.length % 2 != 0) {
796             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
798         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
800         ain1.copyFrom(in1);
825     // in1 = "in", flattened 2-vectors
826     public result_int reduce_my_half2_4(short[] in1) {
827         // Verify that "in1" is non-null.
828         if (in1 == null) {
829             throw new RSIllegalArgumentException("Array \"in1\" is null!");
832         if (in1.length % 2 != 0) {
833             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
835         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
837         ain1.copyFrom(in1);
862     // in1 = "in", flattened 2-vectors
863     public result_int reduce_my_half2_5(short[] in1) {
864         // Verify that "in1" is non-null.
865         if (in1 == null) {
866             throw new RSIllegalArgumentException("Array \"in1\" is null!");
869         if (in1.length % 2 != 0) {
870             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
872         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
874         ain1.copyFrom(in1);
899     // in1 = "in", flattened 2-vectors
900     public result_int reduce_my_half2_6(short[] in1) {
901         // Verify that "in1" is non-null.
902         if (in1 == null) {
903             throw new RSIllegalArgumentException("Array \"in1\" is null!");
906         if (in1.length % 2 != 0) {
907             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
909         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
911         ain1.copyFrom(in1);
936     // in1 = "in", flattened 2-vectors
937     public result_int reduce_my_half2_7(short[] in1) {
938         // Verify that "in1" is non-null.
939         if (in1 == null) {
940             throw new RSIllegalArgumentException("Array \"in1\" is null!");
943         if (in1.length % 2 != 0) {
944             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
946         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
948         ain1.copyFrom(in1);
973     // in1 = "in", flattened 2-vectors
974     public result_int reduce_my_half2_8(short[] in1) {
975         // Verify that "in1" is non-null.
976         if (in1 == null) {
977             throw new RSIllegalArgumentException("Array \"in1\" is null!");
980         if (in1.length % 2 != 0) {
981             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
983         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
985         ain1.copyFrom(in1);
1010     // in1 = "in", flattened 2-vectors
1011     public result_int reduce_my_half2_9(short[] in1) {
1012         // Verify that "in1" is non-null.
1013         if (in1 == null) {
1014             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1017         if (in1.length % 2 != 0) {
1018             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
1020         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
1022         ain1.copyFrom(in1);
1047     // in1 = "in", flattened 2-vectors
1048     public result_int reduce_my_half2_10(short[] in1) {
1049         // Verify that "in1" is non-null.
1050         if (in1 == null) {
1051             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1054         if (in1.length % 2 != 0) {
1055             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
1057         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
1059         ain1.copyFrom(in1);
1084     // in1 = "in", flattened 2-vectors
1085     public result_int reduce_my_half2_11(short[] in1) {
1086         // Verify that "in1" is non-null.
1087         if (in1 == null) {
1088             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1091         if (in1.length % 2 != 0) {
1092             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
1094         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
1096         ain1.copyFrom(in1);
1121     // in1 = "in", flattened 2-vectors
1122     public result_int reduce_my_half2_12(short[] in1) {
1123         // Verify that "in1" is non-null.
1124         if (in1 == null) {
1125             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1128         if (in1.length % 2 != 0) {
1129             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
1131         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
1133         ain1.copyFrom(in1);
1158     // in1 = "in", flattened 2-vectors
1159     public result_int reduce_my_half2_13(short[] in1) {
1160         // Verify that "in1" is non-null.
1161         if (in1 == null) {
1162             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1165         if (in1.length % 2 != 0) {
1166             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
1168         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
1170         ain1.copyFrom(in1);
1195     // in1 = "in", flattened 2-vectors
1196     public result_int reduce_my_half2_14(short[] in1) {
1197         // Verify that "in1" is non-null.
1198         if (in1 == null) {
1199             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1202         if (in1.length % 2 != 0) {
1203             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
1205         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
1207         ain1.copyFrom(in1);
1232     // in1 = "in", flattened 2-vectors
1233     public result_int reduce_my_half2_15(short[] in1) {
1234         // Verify that "in1" is non-null.
1235         if (in1 == null) {
1236             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1239         if (in1.length % 2 != 0) {
1240             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
1242         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_2, in1.length / 2);
1244         ain1.copyFrom(in1);
1269     // in1 = "in", flattened 4-vectors
1270     public result_int reduce_my_half4_0(short[] in1) {
1271         // Verify that "in1" is non-null.
1272         if (in1 == null) {
1273             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1276         if (in1.length % 4 != 0) {
1277             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1279         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1281         ain1.copyFrom(in1);
1306     // in1 = "in", flattened 4-vectors
1307     public result_int reduce_my_half4_1(short[] in1) {
1308         // Verify that "in1" is non-null.
1309         if (in1 == null) {
1310 in1\" is null!");
1313         if (in1.length % 4 != 0) {
1314             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1316         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1318         ain1.copyFrom(in1);
1343     // in1 = "in", flattened 4-vectors
1344     public result_int reduce_my_half4_2(short[] in1) {
1345         // Verify that "in1" is non-null.
1346         if (in1 == null) {
1347             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1350         if (in1.length % 4 != 0) {
1351             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1353         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1355         ain1.copyFrom(in1);
1380     // in1 = "in", flattened 4-vectors
1381     public result_int reduce_my_half4_3(short[] in1) {
1382         // Verify that "in1" is non-null.
1383         if (in1 == null) {
1384             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1387         if (in1.length % 4 != 0) {
1388             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1390         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1392         ain1.copyFrom(in1);
1417     // in1 = "in", flattened 4-vectors
1418     public result_int reduce_my_half4_4(short[] in1) {
1419         // Verify that "in1" is non-null.
1420         if (in1 == null) {
1421             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1424         if (in1.length % 4 != 0) {
1425             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1427         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1429         ain1.copyFrom(in1);
1454     // in1 = "in", flattened 4-vectors
1455     public result_int reduce_my_half4_5(short[] in1) {
1456         // Verify that "in1" is non-null.
1457         if (in1 == null) {
1458             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1461         if (in1.length % 4 != 0) {
1462             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1464         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1466         ain1.copyFrom(in1);
1491     // in1 = "in", flattened 4-vectors
1492     public result_int reduce_my_half4_6(short[] in1) {
1493         // Verify that "in1" is non-null.
1494         if (in1 == null) {
1495             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1498         if (in1.length % 4 != 0) {
1499             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1501         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1503         ain1.copyFrom(in1);
1528     // in1 = "in", flattened 4-vectors
1529     public result_int reduce_my_half4_7(short[] in1) {
1530         // Verify that "in1" is non-null.
1531         if (in1 == null) {
1532             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1535         if (in1.length % 4 != 0) {
1536             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1538         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1540         ain1.copyFrom(in1);
1565     // in1 = "in", flattened 4-vectors
1566     public result_int reduce_my_half4_8(short[] in1) {
1567         // Verify that "in1" is non-null.
1568         if (in1 == null) {
1569             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1572         if (in1.length % 4 != 0) {
1573             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1575         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1577         ain1.copyFrom(in1);
1602     // in1 = "in", flattened 4-vectors
1603     public result_int reduce_my_half4_9(short[] in1) {
1604         // Verify that "in1" is non-null.
1605         if (in1 == null) {
1606             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1609         if (in1.length % 4 != 0) {
1610             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1612         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1614         ain1.copyFrom(in1);
1639     // in1 = "in", flattened 4-vectors
1640     public result_int reduce_my_half4_10(short[] in1) {
1641         // Verify that "in1" is non-null.
1642         if (in1 == null) {
1643             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1646         if (in1.length % 4 != 0) {
1647             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1649         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1651         ain1.copyFrom(in1);
1676     // in1 = "in", flattened 4-vectors
1677     public result_int reduce_my_half4_11(short[] in1) {
1678         // Verify that "in1" is non-null.
1679         if (in1 == null) {
1680             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1683         if (in1.length % 4 != 0) {
1684             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1686         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1688         ain1.copyFrom(in1);
1713     // in1 = "in", flattened 4-vectors
1714     public result_int reduce_my_half4_12(short[] in1) {
1715         // Verify that "in1" is non-null.
1716         if (in1 == null) {
1717             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1720         if (in1.length % 4 != 0) {
1721             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1723 in1.length / 4);
1725         ain1.copyFrom(in1);
1750     // in1 = "in", flattened 4-vectors
1751     public result_int reduce_my_half4_13(short[] in1) {
1752         // Verify that "in1" is non-null.
1753         if (in1 == null) {
1754             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1757         if (in1.length % 4 != 0) {
1758             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1760         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1762         ain1.copyFrom(in1);
1787     // in1 = "in", flattened 4-vectors
1788     public result_int reduce_my_half4_14(short[] in1) {
1789         // Verify that "in1" is non-null.
1790         if (in1 == null) {
1791             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1794         if (in1.length % 4 != 0) {
1795             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1797         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1799         ain1.copyFrom(in1);
1824     // in1 = "in", flattened 4-vectors
1825     public result_int reduce_my_half4_15(short[] in1) {
1826         // Verify that "in1" is non-null.
1827         if (in1 == null) {
1828             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1831         if (in1.length % 4 != 0) {
1832             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
1834         Allocation ain1 = Allocation.createSized(mRSLocal, __F16_4, in1.length / 4);
1836         ain1.copyFrom(in1);
1861     // in1 = "in"
1862     public result_int reduce_my_float_0(float[] in1) {
1863         // Verify that "in1" is non-null.
1864         if (in1 == null) {
1865             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1867         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
1869         ain1.copyFrom(in1);
1894     // in1 = "in"
1895     public result_int reduce_my_float_1(float[] in1) {
1896         // Verify that "in1" is non-null.
1897         if (in1 == null) {
1898             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1900         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
1902         ain1.copyFrom(in1);
1927     // in1 = "in"
1928     public result_int reduce_my_float_2(float[] in1) {
1929         // Verify that "in1" is non-null.
1930         if (in1 == null) {
1931             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1933         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
1935         ain1.copyFrom(in1);
1960     // in1 = "in"
1961     public result_int reduce_my_float_3(float[] in1) {
1962         // Verify that "in1" is non-null.
1963         if (in1 == null) {
1964             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1966         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
1968         ain1.copyFrom(in1);
1993     // in1 = "in"
1994     public result_int reduce_my_float_4(float[] in1) {
1995         // Verify that "in1" is non-null.
1996         if (in1 == null) {
1997             throw new RSIllegalArgumentException("Array \"in1\" is null!");
1999         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2001         ain1.copyFrom(in1);
2026     // in1 = "in"
2027     public result_int reduce_my_float_5(float[] in1) {
2028         // Verify that "in1" is non-null.
2029         if (in1 == null) {
2030             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2032         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2034         ain1.copyFrom(in1);
2059     // in1 = "in"
2060     public result_int reduce_my_float_6(float[] in1) {
2061         // Verify that "in1" is non-null.
2062         if (in1 == null) {
2063             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2065         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2067         ain1.copyFrom(in1);
2092     // in1 = "in"
2093     public result_int reduce_my_float_7(float[] in1) {
2094         // Verify that "in1" is non-null.
2095         if (in1 == null) {
2096             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2098         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2100         ain1.copyFrom(in1);
2125     // in1 = "in"
2126     public result_int reduce_my_float_8(float[] in1) {
2127         // Verify that "in1" is non-null.
2128         if (in1 == null) {
2129             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2131         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2133         ain1.copyFrom(in1);
2158     // in1 = "in"
2159     public result_int reduce_my_float_9(float[] in1) {
2160 in1" is non-null.
2161         if (in1 == null) {
2162             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2164         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2166         ain1.copyFrom(in1);
2191     // in1 = "in"
2192     public result_int reduce_my_float_10(float[] in1) {
2193         // Verify that "in1" is non-null.
2194         if (in1 == null) {
2195             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2197         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2199         ain1.copyFrom(in1);
2224     // in1 = "in"
2225     public result_int reduce_my_float_11(float[] in1) {
2226         // Verify that "in1" is non-null.
2227         if (in1 == null) {
2228             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2230         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2232         ain1.copyFrom(in1);
2257     // in1 = "in"
2258     public result_int reduce_my_float_12(float[] in1) {
2259         // Verify that "in1" is non-null.
2260         if (in1 == null) {
2261             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2263         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2265         ain1.copyFrom(in1);
2290     // in1 = "in"
2291     public result_int reduce_my_float_13(float[] in1) {
2292         // Verify that "in1" is non-null.
2293         if (in1 == null) {
2294             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2296         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2298         ain1.copyFrom(in1);
2323     // in1 = "in"
2324     public result_int reduce_my_float_14(float[] in1) {
2325         // Verify that "in1" is non-null.
2326         if (in1 == null) {
2327             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2329         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2331         ain1.copyFrom(in1);
2356     // in1 = "in"
2357     public result_int reduce_my_float_15(float[] in1) {
2358         // Verify that "in1" is non-null.
2359         if (in1 == null) {
2360             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2362         Allocation ain1 = Allocation.createSized(mRSLocal, __F32, in1.length);
2364         ain1.copyFrom(in1);
2389     // in1 = "in", flattened 2-vectors
2390     public result_int reduce_my_float2_0(float[] in1) {
2391         // Verify that "in1" is non-null.
2392         if (in1 == null) {
2393             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2396         if (in1.length % 2 != 0) {
2397             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2399         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2401         ain1.copyFrom(in1);
2426     // in1 = "in", flattened 2-vectors
2427     public result_int reduce_my_float2_1(float[] in1) {
2428         // Verify that "in1" is non-null.
2429         if (in1 == null) {
2430             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2433         if (in1.length % 2 != 0) {
2434             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2436         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2438         ain1.copyFrom(in1);
2463     // in1 = "in", flattened 2-vectors
2464     public result_int reduce_my_float2_2(float[] in1) {
2465         // Verify that "in1" is non-null.
2466         if (in1 == null) {
2467             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2470         if (in1.length % 2 != 0) {
2471             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2473         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2475         ain1.copyFrom(in1);
2500     // in1 = "in", flattened 2-vectors
2501     public result_int reduce_my_float2_3(float[] in1) {
2502         // Verify that "in1" is non-null.
2503         if (in1 == null) {
2504             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2507         if (in1.length % 2 != 0) {
2508             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2510         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2512         ain1.copyFrom(in1);
2537     // in1 = "in", flattened 2-vectors
2538     public result_int reduce_my_float2_4(float[] in1) {
2539         // Verify that "in1" is non-null.
2540         if (in1 == null) {
2541             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2544         if (in1.length % 2 != 0) {
2545             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2547         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2549         ain1.copyFrom(in1);
2574     // in1 = "in", flattened 2-vectors
2575     public result_int reduce_my_float2_5(float[] in1) {
2576         // Verify that "in1" is non-null.
2577         if (in1 == null) {
2578             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2581         if (in1.length % 2 != 0) {
2582             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2584         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2586         ain1.copyFrom(in1);
2611     // in1 = "in", flattened 2-vectors
2612     public result_int reduce_my_float2_6(float[] in1) {
2613         // Verify that "in1" is non-null.
2614         if (in1 == null) {
2615             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2618         if (in1.length % 2 != 0) {
2619             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2621         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2623         ain1.copyFrom(in1);
2648     // in1 = "in", flattened 2-vectors
2649     public result_int reduce_my_float2_7(float[] in1) {
2650         // Verify that "in1" is non-null.
2651         if (in1 == null) {
2652             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2655         if (in1.length % 2 != 0) {
2656             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2658         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2660         ain1.copyFrom(in1);
2685     // in1 = "in", flattened 2-vectors
2686     public result_int reduce_my_float2_8(float[] in1) {
2687         // Verify that "in1" is non-null.
2688         if (in1 == null) {
2689             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2692         if (in1.length % 2 != 0) {
2693             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2695         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2697         ain1.copyFrom(in1);
2722     // in1 = "in", flattened 2-vectors
2723     public result_int reduce_my_float2_9(float[] in1) {
2724         // Verify that "in1" is non-null.
2725         if (in1 == null) {
2726             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2729         if (in1.length % 2 != 0) {
2730             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2732         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2734         ain1.copyFrom(in1);
2759     // in1 = "in", flattened 2-vectors
2760     public result_int reduce_my_float2_10(float[] in1) {
2761         // Verify that "in1" is non-null.
2762         if (in1 == null) {
2763             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2766         if (in1.length % 2 != 0) {
2767             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2769         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2771         ain1.copyFrom(in1);
2796     // in1 = "in", flattened 2-vectors
2797     public result_int reduce_my_float2_11(float[] in1) {
2798         // Verify that "in1" is non-null.
2799         if (in1 == null) {
2800             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2803         if (in1.length % 2 != 0) {
2804             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2806         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2808         ain1.copyFrom(in1);
2833     // in1 = "in", flattened 2-vectors
2834     public result_int reduce_my_float2_12(float[] in1) {
2835         // Verify that "in1" is non-null.
2836         if (in1 == null) {
2837             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2840         if (in1.length % 2 != 0) {
2841             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2843         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2845         ain1.copyFrom(in1);
2870     // in1 = "in", flattened 2-vectors
2871     public result_int reduce_my_float2_13(float[] in1) {
2872         // Verify that "in1" is non-null.
2873         if (in1 == null) {
2874             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2877         if (in1.length % 2 != 0) {
2878             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2880         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2882         ain1.copyFrom(in1);
2907     // in1 = "in", flattened 2-vectors
2908     public result_int reduce_my_float2_14(float[] in1) {
2909         // Verify that "in1" is non-null.
2910         if (in1 == null) {
2911             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2914         if (in1.length % 2 != 0) {
2915             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2917         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2919         ain1.copyFrom(in1);
2944     // in1 = "in", flattened 2-vectors
2945     public result_int reduce_my_float2_15(float[] in1) {
2946         // Verify that "in1" is non-null.
2947         if (in1 == null) {
2948             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2951         if (in1.length % 2 != 0) {
2952             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
2954         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_2, in1.length / 2);
2956         ain1.copyFrom(in1);
2981     // in1 = "in", flattened 4-vectors
2982     public result_int reduce_my_float4_0(float[] in1) {
2983         // Verify that "in1" is non-null.
2984         if (in1 == null) {
2985             throw new RSIllegalArgumentException("Array \"in1\" is null!");
2988         if (in1.length % 4 != 0) {
2989             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
2991         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
2993         ain1.copyFrom(in1);
3018     // in1 = "in", flattened 4-vectors
3019     public result_int reduce_my_float4_1(float[] in1) {
3020         // Verify that "in1" is non-null.
3021         if (in1 == null) {
3022             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3025         if (in1.length % 4 != 0) {
3026             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3028         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3030         ain1.copyFrom(in1);
3055     // in1 = "in", flattened 4-vectors
3056     public result_int reduce_my_float4_2(float[] in1) {
3057         // Verify that "in1" is non-null.
3058         if (in1 == null) {
3059             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3062         if (in1.length % 4 != 0) {
3063             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3065         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3067         ain1.copyFrom(in1);
3092     // in1 = "in", flattened 4-vectors
3093     public result_int reduce_my_float4_3(float[] in1) {
3094         // Verify that "in1" is non-null.
3095         if (in1 == null) {
3096             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3099         if (in1.length % 4 != 0) {
3100             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3102         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3104         ain1.copyFrom(in1);
3129     // in1 = "in", flattened 4-vectors
3130     public result_int reduce_my_float4_4(float[] in1) {
3131         // Verify that "in1" is non-null.
3132         if (in1 == null) {
3133             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3136         if (in1.length % 4 != 0) {
3137             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3139         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3141         ain1.copyFrom(in1);
3166     // in1 = "in", flattened 4-vectors
3167     public result_int reduce_my_float4_5(float[] in1) {
3168         // Verify that "in1" is non-null.
3169         if (in1 == null) {
3170             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3173         if (in1.length % 4 != 0) {
3174             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3176         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3178         ain1.copyFrom(in1);
3203     // in1 = "in", flattened 4-vectors
3204     public result_int reduce_my_float4_6(float[] in1) {
3205         // Verify that "in1" is non-null.
3206         if (in1 == null) {
3207             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3210         if (in1.length % 4 != 0) {
3211             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3213         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3215         ain1.copyFrom(in1);
3240     // in1 = "in", flattened 4-vectors
3241     public result_int reduce_my_float4_7(float[] in1) {
3242         // Verify that "in1" is non-null.
3243         if (in1 == null) {
3244             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3247         if (in1.length % 4 != 0) {
3248             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3250         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3252         ain1.copyFrom(in1);
3277     // in1 = "in", flattened 4-vectors
3278     public result_int reduce_my_float4_8(float[] in1) {
3279         // Verify that "in1" is non-null.
3280         if (in1 == null) {
3281             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3284         if (in1.length % 4 != 0) {
3285             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3287         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3289         ain1.copyFrom(in1);
3314     // in1 = "in", flattened 4-vectors
3315     public result_int reduce_my_float4_9(float[] in1) {
3316         // Verify that "in1" is non-null.
3317         if (in1 == null) {
3318             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3321         if (in1.length % 4 != 0) {
3322             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3324         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3326         ain1.copyFrom(in1);
3351     // in1 = "in", flattened 4-vectors
3352     public result_int reduce_my_float4_10(float[] in1) {
3353         // Verify that "in1" is non-null.
3354         if (in1 == null) {
3355             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3358         if (in1.length % 4 != 0) {
3359             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3361         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3363         ain1.copyFrom(in1);
3388     // in1 = "in", flattened 4-vectors
3389     public result_int reduce_my_float4_11(float[] in1) {
3390         // Verify that "in1" is non-null.
3391         if (in1 == null) {
3392             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3395         if (in1.length % 4 != 0) {
3396             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3398         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3400         ain1.copyFrom(in1);
3425     // in1 = "in", flattened 4-vectors
3426     public result_int reduce_my_float4_12(float[] in1) {
3427         // Verify that "in1" is non-null.
3428         if (in1 == null) {
3429             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3432         if (in1.length % 4 != 0) {
3433             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3435         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3437         ain1.copyFrom(in1);
3462     // in1 = "in", flattened 4-vectors
3463     public result_int reduce_my_float4_13(float[] in1) {
3464         // Verify that "in1" is non-null.
3465         if (in1 == null) {
3466             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3469         if (in1.length % 4 != 0) {
3470             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3472         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3474         ain1.copyFrom(in1);
3499     // in1 = "in", flattened 4-vectors
3500     public result_int reduce_my_float4_14(float[] in1) {
3501         // Verify that "in1" is non-null.
3502         if (in1 == null) {
3503             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3506         if (in1.length % 4 != 0) {
3507             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3509         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3511         ain1.copyFrom(in1);
3536     // in1 = "in", flattened 4-vectors
3537     public result_int reduce_my_float4_15(float[] in1) {
3538         // Verify that "in1" is non-null.
3539         if (in1 == null) {
3540             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3543         if (in1.length % 4 != 0) {
3544             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
3546         Allocation ain1 = Allocation.createSized(mRSLocal, __F32_4, in1.length / 4);
3548         ain1.copyFrom(in1);
3573     // in1 = "in"
3574     public result_int reduce_my_double_0(double[] in1) {
3575         // Verify that "in1" is non-null.
3576         if (in1 == null) {
3577             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3579         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3581         ain1.copyFrom(in1);
3606     // in1 = "in"
3607     public result_int reduce_my_double_1(double[] in1) {
3608         // Verify that "in1" is non-null.
3609         if (in1 == null) {
3610             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3612         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3614         ain1.copyFrom(in1);
3639     // in1 = "in"
3640     public result_int reduce_my_double_2(double[] in1) {
3641         // Verify that "in1" is non-null.
3642         if (in1 == null) {
3643             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3645         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3647         ain1.copyFrom(in1);
3672     // in1 = "in"
3673     public result_int reduce_my_double_3(double[] in1) {
3674         // Verify that "in1" is non-null.
3675         if (in1 == null) {
3676             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3678         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3680         ain1.copyFrom(in1);
3705     // in1 = "in"
3706     public result_int reduce_my_double_4(double[] in1) {
3707         // Verify that "in1" is non-null.
3708         if (in1 == null) {
3709             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3711         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3713         ain1.copyFrom(in1);
3738     // in1 = "in"
3739     public result_int reduce_my_double_5(double[] in1) {
3740         // Verify that "in1" is non-null.
3741         if (in1 == null) {
3742             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3744         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3746         ain1.copyFrom(in1);
3771     // in1 = "in"
3772     public result_int reduce_my_double_6(double[] in1) {
3773         // Verify that "in1" is non-null.
3774         if (in1 == null) {
3775             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3777         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3779         ain1.copyFrom(in1);
3804     // in1 = "in"
3805     public result_int reduce_my_double_7(double[] in1) {
3806         // Verify that "in1" is non-null.
3807         if (in1 == null) {
3808             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3810         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3812         ain1.copyFrom(in1);
3837     // in1 = "in"
3838     public result_int reduce_my_double_8(double[] in1) {
3839 in1" is non-null.
3840         if (in1 == null) {
3841             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3843         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3845         ain1.copyFrom(in1);
3870     // in1 = "in"
3871     public result_int reduce_my_double_9(double[] in1) {
3872         // Verify that "in1" is non-null.
3873         if (in1 == null) {
3874             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3876         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3878         ain1.copyFrom(in1);
3903     // in1 = "in"
3904     public result_int reduce_my_double_10(double[] in1) {
3905         // Verify that "in1" is non-null.
3906         if (in1 == null) {
3907             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3909         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3911         ain1.copyFrom(in1);
3936     // in1 = "in"
3937     public result_int reduce_my_double_11(double[] in1) {
3938         // Verify that "in1" is non-null.
3939         if (in1 == null) {
3940             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3942         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3944         ain1.copyFrom(in1);
3969     // in1 = "in"
3970     public result_int reduce_my_double_12(double[] in1) {
3971         // Verify that "in1" is non-null.
3972         if (in1 == null) {
3973             throw new RSIllegalArgumentException("Array \"in1\" is null!");
3975         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
3977         ain1.copyFrom(in1);
4002     // in1 = "in"
4003     public result_int reduce_my_double_13(double[] in1) {
4004         // Verify that "in1" is non-null.
4005         if (in1 == null) {
4006             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4008         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
4010         ain1.copyFrom(in1);
4035     // in1 = "in"
4036     public result_int reduce_my_double_14(double[] in1) {
4037         // Verify that "in1" is non-null.
4038         if (in1 == null) {
4039             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4041         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
4043         ain1.copyFrom(in1);
4068     // in1 = "in"
4069     public result_int reduce_my_double_15(double[] in1) {
4070         // Verify that "in1" is non-null.
4071         if (in1 == null) {
4072             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4074         Allocation ain1 = Allocation.createSized(mRSLocal, __F64, in1.length);
4076         ain1.copyFrom(in1);
4101     // in1 = "in", flattened 2-vectors
4102     public result_int reduce_my_double2_0(double[] in1) {
4103         // Verify that "in1" is non-null.
4104         if (in1 == null) {
4105             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4108         if (in1.length % 2 != 0) {
4109             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4111         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4113         ain1.copyFrom(in1);
4138     // in1 = "in", flattened 2-vectors
4139     public result_int reduce_my_double2_1(double[] in1) {
4140         // Verify that "in1" is non-null.
4141         if (in1 == null) {
4142             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4145         if (in1.length % 2 != 0) {
4146             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4148         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4150         ain1.copyFrom(in1);
4175     // in1 = "in", flattened 2-vectors
4176     public result_int reduce_my_double2_2(double[] in1) {
4177         // Verify that "in1" is non-null.
4178         if (in1 == null) {
4179             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4182         if (in1.length % 2 != 0) {
4183             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4185         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4187         ain1.copyFrom(in1);
4212     // in1 = "in", flattened 2-vectors
4213     public result_int reduce_my_double2_3(double[] in1) {
4214         // Verify that "in1" is non-null.
4215         if (in1 == null) {
4216             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4219         if (in1.length % 2 != 0) {
4220             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4222         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4224         ain1.copyFrom(in1);
4249     // in1 = "in", flattened 2-vectors
4250     public result_int reduce_my_double2_4(double[] in1) {
4251         // Verify that "in1" is non-null.
4252         if (in1 == null) {
4253             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4256         if (in1.length % 2 != 0) {
4257             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4259         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4261         ain1.copyFrom(in1);
4286     // in1 = "in", flattened 2-vectors
4287     public result_int reduce_my_double2_5(double[] in1) {
4288         // Verify that "in1" is non-null.
4289         if (in1 == null) {
4290             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4293         if (in1.length % 2 != 0) {
4294             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4296         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4298         ain1.copyFrom(in1);
4323     // in1 = "in", flattened 2-vectors
4324     public result_int reduce_my_double2_6(double[] in1) {
4325         // Verify that "in1" is non-null.
4326         if (in1 == null) {
4327             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4330         if (in1.length % 2 != 0) {
4331             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4333         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4335         ain1.copyFrom(in1);
4360     // in1 = "in", flattened 2-vectors
4361     public result_int reduce_my_double2_7(double[] in1) {
4362         // Verify that "in1" is non-null.
4363         if (in1 == null) {
4364             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4367         if (in1.length % 2 != 0) {
4368             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4370         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4372         ain1.copyFrom(in1);
4397     // in1 = "in", flattened 2-vectors
4398     public result_int reduce_my_double2_8(double[] in1) {
4399         // Verify that "in1" is non-null.
4400         if (in1 == null) {
4401             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4404         if (in1.length % 2 != 0) {
4405             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4407         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4409         ain1.copyFrom(in1);
4434     // in1 = "in", flattened 2-vectors
4435     public result_int reduce_my_double2_9(double[] in1) {
4436         // Verify that "in1" is non-null.
4437         if (in1 == null) {
4438             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4441         if (in1.length % 2 != 0) {
4442             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4444         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4446         ain1.copyFrom(in1);
4471     // in1 = "in", flattened 2-vectors
4472     public result_int reduce_my_double2_10(double[] in1) {
4473         // Verify that "in1" is non-null.
4474         if (in1 == null) {
4475             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4478         if (in1.length % 2 != 0) {
4479             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4481         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4483         ain1.copyFrom(in1);
4508     // in1 = "in", flattened 2-vectors
4509     public result_int reduce_my_double2_11(double[] in1) {
4510         // Verify that "in1" is non-null.
4511         if (in1 == null) {
4512             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4515         if (in1.length % 2 != 0) {
4516             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4518         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4520         ain1.copyFrom(in1);
4545     // in1 = "in", flattened 2-vectors
4546     public result_int reduce_my_double2_12(double[] in1) {
4547         // Verify that "in1" is non-null.
4548         if (in1 == null) {
4549             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4552         if (in1.length % 2 != 0) {
4553             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4555         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4557         ain1.copyFrom(in1);
4582     // in1 = "in", flattened 2-vectors
4583     public result_int reduce_my_double2_13(double[] in1) {
4584         // Verify that "in1" is non-null.
4585         if (in1 == null) {
4586             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4589         if (in1.length % 2 != 0) {
4590             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4592         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4594         ain1.copyFrom(in1);
4619     // in1 = "in", flattened 2-vectors
4620     public result_int reduce_my_double2_14(double[] in1) {
4621         // Verify that "in1" is non-null.
4622         if (in1 == null) {
4623             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4626         if (in1.length % 2 != 0) {
4627             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4629         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4631         ain1.copyFrom(in1);
4656     // in1 = "in", flattened 2-vectors
4657     public result_int reduce_my_double2_15(double[] in1) {
4658         // Verify that "in1" is non-null.
4659         if (in1 == null) {
4660             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4663         if (in1.length % 2 != 0) {
4664             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
4666         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_2, in1.length / 2);
4668         ain1.copyFrom(in1);
4693     // in1 = "in", flattened 4-vectors
4694     public result_int reduce_my_double4_0(double[] in1) {
4695         // Verify that "in1" is non-null.
4696         if (in1 == null) {
4697             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4700         if (in1.length % 4 != 0) {
4701             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4703         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4705         ain1.copyFrom(in1);
4730     // in1 = "in", flattened 4-vectors
4731     public result_int reduce_my_double4_1(double[] in1) {
4732         // Verify that "in1" is non-null.
4733         if (in1 == null) {
4734             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4737         if (in1.length % 4 != 0) {
4738             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4740         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4742         ain1.copyFrom(in1);
4767     // in1 = "in", flattened 4-vectors
4768     public result_int reduce_my_double4_2(double[] in1) {
4769         // Verify that "in1" is non-null.
4770         if (in1 == null) {
4771             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4774         if (in1.length % 4 != 0) {
4775             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4777         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4779         ain1.copyFrom(in1);
4804     // in1 = "in", flattened 4-vectors
4805     public result_int reduce_my_double4_3(double[] in1) {
4806         // Verify that "in1" is non-null.
4807         if (in1 == null) {
4808             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4811         if (in1.length % 4 != 0) {
4812             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4814         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4816         ain1.copyFrom(in1);
4841     // in1 = "in", flattened 4-vectors
4842     public result_int reduce_my_double4_4(double[] in1) {
4843         // Verify that "in1" is non-null.
4844         if (in1 == null) {
4845             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4848         if (in1.length % 4 != 0) {
4849             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4851         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4853         ain1.copyFrom(in1);
4878     // in1 = "in", flattened 4-vectors
4879     public result_int reduce_my_double4_5(double[] in1) {
4880         // Verify that "in1" is non-null.
4881         if (in1 == null) {
4882             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4885         if (in1.length % 4 != 0) {
4886             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4888         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4890         ain1.copyFrom(in1);
4915     // in1 = "in", flattened 4-vectors
4916     public result_int reduce_my_double4_6(double[] in1) {
4917         // Verify that "in1" is non-null.
4918         if (in1 == null) {
4919             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4922         if (in1.length % 4 != 0) {
4923             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4925         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4927         ain1.copyFrom(in1);
4952     // in1 = "in", flattened 4-vectors
4953     public result_int reduce_my_double4_7(double[] in1) {
4954         // Verify that "in1" is non-null.
4955         if (in1 == null) {
4956             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4959         if (in1.length % 4 != 0) {
4960             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4962         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
4964         ain1.copyFrom(in1);
4989     // in1 = "in", flattened 4-vectors
4990     public result_int reduce_my_double4_8(double[] in1) {
4991         // Verify that "in1" is non-null.
4992         if (in1 == null) {
4993             throw new RSIllegalArgumentException("Array \"in1\" is null!");
4996         if (in1.length % 4 != 0) {
4997             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
4999         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5001         ain1.copyFrom(in1);
5026     // in1 = "in", flattened 4-vectors
5027     public result_int reduce_my_double4_9(double[] in1) {
5028         // Verify that "in1" is non-null.
5029         if (in1 == null) {
5030             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5033         if (in1.length % 4 != 0) {
5034             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5036         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5038         ain1.copyFrom(in1);
5063     // in1 = "in", flattened 4-vectors
5064     public result_int reduce_my_double4_10(double[] in1) {
5065         // Verify that "in1" is non-null.
5066         if (in1 == null) {
5067             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5070         if (in1.length % 4 != 0) {
5071             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5073         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5075         ain1.copyFrom(in1);
5100     // in1 = "in", flattened 4-vectors
5101     public result_int reduce_my_double4_11(double[] in1) {
5102         // Verify that "in1" is non-null.
5103         if (in1 == null) {
5104             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5107         if (in1.length % 4 != 0) {
5108             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5110         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5112         ain1.copyFrom(in1);
5137     // in1 = "in", flattened 4-vectors
5138     public result_int reduce_my_double4_12(double[] in1) {
5139         // Verify that "in1" is non-null.
5140         if (in1 == null) {
5141             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5144         if (in1.length % 4 != 0) {
5145             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5147         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5149         ain1.copyFrom(in1);
5174     // in1 = "in", flattened 4-vectors
5175     public result_int reduce_my_double4_13(double[] in1) {
5176         // Verify that "in1" is non-null.
5177         if (in1 == null) {
5178             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5181         if (in1.length % 4 != 0) {
5182             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5184         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5186         ain1.copyFrom(in1);
5211     // in1 = "in", flattened 4-vectors
5212     public result_int reduce_my_double4_14(double[] in1) {
5213         // Verify that "in1" is non-null.
5214         if (in1 == null) {
5215             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5218         if (in1.length % 4 != 0) {
5219             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5221         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5223         ain1.copyFrom(in1);
5248     // in1 = "in", flattened 4-vectors
5249     public result_int reduce_my_double4_15(double[] in1) {
5250         // Verify that "in1" is non-null.
5251         if (in1 == null) {
5252             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5255         if (in1.length % 4 != 0) {
5256             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
5258         Allocation ain1 = Allocation.createSized(mRSLocal, __F64_4, in1.length / 4);
5260         ain1.copyFrom(in1);
5285     // in1 = "in"
5286     public result_int reduce_my_char_0(byte[] in1) {
5287         // Verify that "in1" is non-null.
5288         if (in1 == null) {
5289             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5291         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5293         ain1.copyFrom(in1);
5318     // in1 = "in"
5319     public result_int reduce_my_char_1(byte[] in1) {
5320         // Verify that "in1" is non-null.
5321         if (in1 == null) {
5322             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5324         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5326         ain1.copyFrom(in1);
5351     // in1 = "in"
5352     public result_int reduce_my_char_2(byte[] in1) {
5353         // Verify that "in1" is non-null.
5354         if (in1 == null) {
5355             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5357         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5359         ain1.copyFrom(in1);
5384     // in1 = "in"
5385     public result_int reduce_my_char_3(byte[] in1) {
5386         // Verify that "in1" is non-null.
5387         if (in1 == null) {
5388             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5390         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5392         ain1.copyFrom(in1);
5417     // in1 = "in"
5418     public result_int reduce_my_char_4(byte[] in1) {
5419         // Verify that "in1" is non-null.
5420         if (in1 == null) {
5421             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5423         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5425         ain1.copyFrom(in1);
5450     // in1 = "in"
5451     public result_int reduce_my_char_5(byte[] in1) {
5452         // Verify that "in1" is non-null.
5453         if (in1 == null) {
5454             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5456         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5458         ain1.copyFrom(in1);
5483     // in1 = "in"
5484     public result_int reduce_my_char_6(byte[] in1) {
5485         // Verify that "in1" is non-null.
5486         if (in1 == null) {
5487             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5489         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5491         ain1.copyFrom(in1);
5516     // in1 = "in"
5517     public result_int reduce_my_char_7(byte[] in1) {
5518         // Verify that "in1" is non-null.
5519         if (in1 == null) {
5520             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5522         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5524         ain1.copyFrom(in1);
5549     // in1 = "in"
5550     public result_int reduce_my_char_8(byte[] in1) {
5551         // Verify that "in1" is non-null.
5552         if (in1 == null) {
5553             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5555         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5557         ain1.copyFrom(in1);
5582     // in1 = "in"
5583     public result_int reduce_my_char_9(byte[] in1) {
5584         // Verify that "in1" is non-null.
5585         if (in1 == null) {
5586             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5588         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5590         ain1.copyFrom(in1);
5615     // in1 = "in"
5616     public result_int reduce_my_char_10(byte[] in1) {
5617         // Verify that "in1" is non-null.
5618         if (in1 == null) {
5619             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5621         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5623         ain1.copyFrom(in1);
5648     // in1 = "in"
5649     public result_int reduce_my_char_11(byte[] in1) {
5650         // Verify that "in1" is non-null.
5651         if (in1 == null) {
5652             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5654         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5656         ain1.copyFrom(in1);
5681     // in1 = "in"
5682     public result_int reduce_my_char_12(byte[] in1) {
5683         // Verify that "in1" is non-null.
5684         if (in1 == null) {
5685             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5687         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5689         ain1.copyFrom(in1);
5714     // in1 = "in"
5715     public result_int reduce_my_char_13(byte[] in1) {
5716         // Verify that "in1" is non-null.
5717         if (in1 == null) {
5718             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5720         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5722         ain1.copyFrom(in1);
5747     // in1 = "in"
5748     public result_int reduce_my_char_14(byte[] in1) {
5749         // Verify that "in1" is non-null.
5750         if (in1 == null) {
5751             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5753         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5755         ain1.copyFrom(in1);
5780     // in1 = "in"
5781     public result_int reduce_my_char_15(byte[] in1) {
5782         // Verify that "in1" is non-null.
5783         if (in1 == null) {
5784             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5786         Allocation ain1 = Allocation.createSized(mRSLocal, __I8, in1.length);
5788         ain1.copyFrom(in1);
5813     // in1 = "in", flattened 2-vectors
5814     public result_int reduce_my_char2_0(byte[] in1) {
5815         // Verify that "in1" is non-null.
5816         if (in1 == null) {
5817             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5820         if (in1.length % 2 != 0) {
5821             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
5823         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
5825         ain1.copyFrom(in1);
5850     // in1 = "in", flattened 2-vectors
5851     public result_int reduce_my_char2_1(byte[] in1) {
5852         // Verify that "in1" is non-null.
5853         if (in1 == null) {
5854             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5857         if (in1.length % 2 != 0) {
5858             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
5860         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
5862         ain1.copyFrom(in1);
5887     // in1 = "in", flattened 2-vectors
5888     public result_int reduce_my_char2_2(byte[] in1) {
5889         // Verify that "in1" is non-null.
5890         if (in1 == null) {
5891             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5894         if (in1.length % 2 != 0) {
5895             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
5897         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
5899         ain1.copyFrom(in1);
5924     // in1 = "in", flattened 2-vectors
5925     public result_int reduce_my_char2_3(byte[] in1) {
5926         // Verify that "in1" is non-null.
5927         if (in1 == null) {
5928             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5931         if (in1.length % 2 != 0) {
5932             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
5934         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
5936         ain1.copyFrom(in1);
5961     // in1 = "in", flattened 2-vectors
5962     public result_int reduce_my_char2_4(byte[] in1) {
5963         // Verify that "in1" is non-null.
5964         if (in1 == null) {
5965             throw new RSIllegalArgumentException("Array \"in1\" is null!");
5968         if (in1.length % 2 != 0) {
5969             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
5971         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
5973         ain1.copyFrom(in1);
5998     // in1 = "in", flattened 2-vectors
5999     public result_int reduce_my_char2_5(byte[] in1) {
6000         // Verify that "in1" is non-null.
6001         if (in1 == null) {
6002             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6005         if (in1.length % 2 != 0) {
6006             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6008         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6010         ain1.copyFrom(in1);
6035     // in1 = "in", flattened 2-vectors
6036     public result_int reduce_my_char2_6(byte[] in1) {
6037         // Verify that "in1" is non-null.
6038         if (in1 == null) {
6039             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6042         if (in1.length % 2 != 0) {
6043             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6045         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6047         ain1.copyFrom(in1);
6072     // in1 = "in", flattened 2-vectors
6073     public result_int reduce_my_char2_7(byte[] in1) {
6074         // Verify that "in1" is non-null.
6075         if (in1 == null) {
6076             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6079         if (in1.length % 2 != 0) {
6080             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6082         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6084         ain1.copyFrom(in1);
6109     // in1 = "in", flattened 2-vectors
6110     public result_int reduce_my_char2_8(byte[] in1) {
6111         // Verify that "in1" is non-null.
6112         if (in1 == null) {
6113             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6116         if (in1.length % 2 != 0) {
6117             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6119         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6121         ain1.copyFrom(in1);
6146     // in1 = "in", flattened 2-vectors
6147     public result_int reduce_my_char2_9(byte[] in1) {
6148         // Verify that "in1" is non-null.
6149         if (in1 == null) {
6150             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6153         if (in1.length % 2 != 0) {
6154             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6156         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6158         ain1.copyFrom(in1);
6183     // in1 = "in", flattened 2-vectors
6184     public result_int reduce_my_char2_10(byte[] in1) {
6185         // Verify that "in1" is non-null.
6186         if (in1 == null) {
6187             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6190         if (in1.length % 2 != 0) {
6191             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6193         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6195         ain1.copyFrom(in1);
6220     // in1 = "in", flattened 2-vectors
6221     public result_int reduce_my_char2_11(byte[] in1) {
6222         // Verify that "in1" is non-null.
6223         if (in1 == null) {
6224             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6227         if (in1.length % 2 != 0) {
6228             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6230         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6232         ain1.copyFrom(in1);
6257     // in1 = "in", flattened 2-vectors
6258     public result_int reduce_my_char2_12(byte[] in1) {
6259         // Verify that "in1" is non-null.
6260         if (in1 == null) {
6261             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6264         if (in1.length % 2 != 0) {
6265             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6267         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6269         ain1.copyFrom(in1);
6294     // in1 = "in", flattened 2-vectors
6295     public result_int reduce_my_char2_13(byte[] in1) {
6296         // Verify that "in1" is non-null.
6297         if (in1 == null) {
6298             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6301         if (in1.length % 2 != 0) {
6302             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6304         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6306         ain1.copyFrom(in1);
6331     // in1 = "in", flattened 2-vectors
6332     public result_int reduce_my_char2_14(byte[] in1) {
6333         // Verify that "in1" is non-null.
6334         if (in1 == null) {
6335             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6338         if (in1.length % 2 != 0) {
6339             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6341         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6343         ain1.copyFrom(in1);
6368     // in1 = "in", flattened 2-vectors
6369     public result_int reduce_my_char2_15(byte[] in1) {
6370         // Verify that "in1" is non-null.
6371         if (in1 == null) {
6372             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6375         if (in1.length % 2 != 0) {
6376             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
6378         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_2, in1.length / 2);
6380         ain1.copyFrom(in1);
6405     // in1 = "in", flattened 4-vectors
6406     public result_int reduce_my_char4_0(byte[] in1) {
6407         // Verify that "in1" is non-null.
6408         if (in1 == null) {
6409             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6412         if (in1.length % 4 != 0) {
6413             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6415         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6417         ain1.copyFrom(in1);
6442     // in1 = "in", flattened 4-vectors
6443     public result_int reduce_my_char4_1(byte[] in1) {
6444         // Verify that "in1" is non-null.
6445         if (in1 == null) {
6446             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6449         if (in1.length % 4 != 0) {
6450             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6452         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6454         ain1.copyFrom(in1);
6479     // in1 = "in", flattened 4-vectors
6480     public result_int reduce_my_char4_2(byte[] in1) {
6481         // Verify that "in1" is non-null.
6482         if (in1 == null) {
6483             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6486         if (in1.length % 4 != 0) {
6487             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6489         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6491         ain1.copyFrom(in1);
6516     // in1 = "in", flattened 4-vectors
6517     public result_int reduce_my_char4_3(byte[] in1) {
6518         // Verify that "in1" is non-null.
6519         if (in1 == null) {
6520             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6523         if (in1.length % 4 != 0) {
6524             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6526         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6528         ain1.copyFrom(in1);
6553     // in1 = "in", flattened 4-vectors
6554     public result_int reduce_my_char4_4(byte[] in1) {
6555         // Verify that "in1" is non-null.
6556         if (in1 == null) {
6557             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6560         if (in1.length % 4 != 0) {
6561             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6563         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6565         ain1.copyFrom(in1);
6590     // in1 = "in", flattened 4-vectors
6591     public result_int reduce_my_char4_5(byte[] in1) {
6592         // Verify that "in1" is non-null.
6593         if (in1 == null) {
6594             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6597         if (in1.length % 4 != 0) {
6598             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6600         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6602         ain1.copyFrom(in1);
6627     // in1 = "in", flattened 4-vectors
6628     public result_int reduce_my_char4_6(byte[] in1) {
6629         // Verify that "in1" is non-null.
6630         if (in1 == null) {
6631             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6634         if (in1.length % 4 != 0) {
6635             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6637         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6639         ain1.copyFrom(in1);
6664     // in1 = "in", flattened 4-vectors
6665     public result_int reduce_my_char4_7(byte[] in1) {
6666         // Verify that "in1" is non-null.
6667         if (in1 == null) {
6668             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6671         if (in1.length % 4 != 0) {
6672             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6674         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6676         ain1.copyFrom(in1);
6701     // in1 = "in", flattened 4-vectors
6702     public result_int reduce_my_char4_8(byte[] in1) {
6703         // Verify that "in1" is non-null.
6704         if (in1 == null) {
6705             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6708         if (in1.length % 4 != 0) {
6709             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6711         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6713         ain1.copyFrom(in1);
6738     // in1 = "in", flattened 4-vectors
6739     public result_int reduce_my_char4_9(byte[] in1) {
6740         // Verify that "in1" is non-null.
6741         if (in1 == null) {
6742             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6745         if (in1.length % 4 != 0) {
6746             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6748         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6750         ain1.copyFrom(in1);
6775     // in1 = "in", flattened 4-vectors
6776     public result_int reduce_my_char4_10(byte[] in1) {
6777         // Verify that "in1" is non-null.
6778 in1 == null) {
6779             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6782         if (in1.length % 4 != 0) {
6783             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6785         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6787         ain1.copyFrom(in1);
6812     // in1 = "in", flattened 4-vectors
6813     public result_int reduce_my_char4_11(byte[] in1) {
6814         // Verify that "in1" is non-null.
6815         if (in1 == null) {
6816             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6819         if (in1.length % 4 != 0) {
6820             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6822         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6824         ain1.copyFrom(in1);
6849     // in1 = "in", flattened 4-vectors
6850     public result_int reduce_my_char4_12(byte[] in1) {
6851         // Verify that "in1" is non-null.
6852         if (in1 == null) {
6853             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6856         if (in1.length % 4 != 0) {
6857             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6859         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6861         ain1.copyFrom(in1);
6886     // in1 = "in", flattened 4-vectors
6887     public result_int reduce_my_char4_13(byte[] in1) {
6888         // Verify that "in1" is non-null.
6889         if (in1 == null) {
6890             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6893         if (in1.length % 4 != 0) {
6894             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6896         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6898         ain1.copyFrom(in1);
6923     // in1 = "in", flattened 4-vectors
6924     public result_int reduce_my_char4_14(byte[] in1) {
6925         // Verify that "in1" is non-null.
6926         if (in1 == null) {
6927             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6930         if (in1.length % 4 != 0) {
6931             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6933         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6935         ain1.copyFrom(in1);
6960     // in1 = "in", flattened 4-vectors
6961     public result_int reduce_my_char4_15(byte[] in1) {
6962         // Verify that "in1" is non-null.
6963         if (in1 == null) {
6964             throw new RSIllegalArgumentException("Array \"in1\" is null!");
6967         if (in1.length % 4 != 0) {
6968             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
6970         Allocation ain1 = Allocation.createSized(mRSLocal, __I8_4, in1.length / 4);
6972         ain1.copyFrom(in1);
6997     // in1 = "in"
6998     public result_int reduce_my_short_0(short[] in1) {
6999         // Verify that "in1" is non-null.
7000         if (in1 == null) {
7001             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7003         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7005         ain1.copyFrom(in1);
7030     // in1 = "in"
7031     public result_int reduce_my_short_1(short[] in1) {
7032         // Verify that "in1" is non-null.
7033         if (in1 == null) {
7034             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7036         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7038         ain1.copyFrom(in1);
7063     // in1 = "in"
7064     public result_int reduce_my_short_2(short[] in1) {
7065         // Verify that "in1" is non-null.
7066         if (in1 == null) {
7067             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7069         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7071         ain1.copyFrom(in1);
7096     // in1 = "in"
7097     public result_int reduce_my_short_3(short[] in1) {
7098         // Verify that "in1" is non-null.
7099         if (in1 == null) {
7100             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7102         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7104         ain1.copyFrom(in1);
7129     // in1 = "in"
7130     public result_int reduce_my_short_4(short[] in1) {
7131         // Verify that "in1" is non-null.
7132         if (in1 == null) {
7133             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7135         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7137         ain1.copyFrom(in1);
7162     // in1 = "in"
7163     public result_int reduce_my_short_5(short[] in1) {
7164         // Verify that "in1" is non-null.
7165         if (in1 == null) {
7166             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7168         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7170         ain1.copyFrom(in1);
7195     // in1 = "in"
7196     public result_int reduce_my_short_6(short[] in1) {
7197         // Verify that "in1" is non-null.
7198         if (in1 == null) {
7199             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7201         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7203         ain1.copyFrom(in1);
7228     // in1 = "in"
7229     public result_int reduce_my_short_7(short[] in1) {
7230         // Verify that "in1" is non-null.
7231         if (in1 == null) {
7232             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7234         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7236         ain1.copyFrom(in1);
7261     // in1 = "in"
7262     public result_int reduce_my_short_8(short[] in1) {
7263         // Verify that "in1" is non-null.
7264         if (in1 == null) {
7265             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7267         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7269         ain1.copyFrom(in1);
7294     // in1 = "in"
7295     public result_int reduce_my_short_9(short[] in1) {
7296         // Verify that "in1" is non-null.
7297         if (in1 == null) {
7298             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7300         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7302         ain1.copyFrom(in1);
7327     // in1 = "in"
7328     public result_int reduce_my_short_10(short[] in1) {
7329         // Verify that "in1" is non-null.
7330         if (in1 == null) {
7331             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7333         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7335         ain1.copyFrom(in1);
7360     // in1 = "in"
7361     public result_int reduce_my_short_11(short[] in1) {
7362         // Verify that "in1" is non-null.
7363         if (in1 == null) {
7364             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7366         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7368         ain1.copyFrom(in1);
7393     // in1 = "in"
7394     public result_int reduce_my_short_12(short[] in1) {
7395         // Verify that "in1" is non-null.
7396         if (in1 == null) {
7397             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7399         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7401         ain1.copyFrom(in1);
7426     // in1 = "in"
7427     public result_int reduce_my_short_13(short[] in1) {
7428         // Verify that "in1" is non-null.
7429         if (in1 == null) {
7430             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7432         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7434         ain1.copyFrom(in1);
7459     // in1 = "in"
7460     public result_int reduce_my_short_14(short[] in1) {
7461         // Verify that "in1" is non-null.
7462         if (in1 == null) {
7463             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7465         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7467         ain1.copyFrom(in1);
7492     // in1 = "in"
7493     public result_int reduce_my_short_15(short[] in1) {
7494         // Verify that "in1" is non-null.
7495         if (in1 == null) {
7496             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7498         Allocation ain1 = Allocation.createSized(mRSLocal, __I16, in1.length);
7500         ain1.copyFrom(in1);
7525     // in1 = "in", flattened 2-vectors
7526     public result_int reduce_my_short2_0(short[] in1) {
7527         // Verify that "in1" is non-null.
7528         if (in1 == null) {
7529             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7532         if (in1.length % 2 != 0) {
7533             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7535         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7537         ain1.copyFrom(in1);
7562     // in1 = "in", flattened 2-vectors
7563     public result_int reduce_my_short2_1(short[] in1) {
7564         // Verify that "in1" is non-null.
7565         if (in1 == null) {
7566             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7569         if (in1.length % 2 != 0) {
7570             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7572         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7574         ain1.copyFrom(in1);
7599     // in1 = "in", flattened 2-vectors
7600     public result_int reduce_my_short2_2(short[] in1) {
7601         // Verify that "in1" is non-null.
7602         if (in1 == null) {
7603             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7606         if (in1.length % 2 != 0) {
7607             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7609         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7611         ain1.copyFrom(in1);
7636     // in1 = "in", flattened 2-vectors
7637     public result_int reduce_my_short2_3(short[] in1) {
7638         // Verify that "in1" is non-null.
7639         if (in1 == null) {
7640             throw new RSIllegalArgumentException("Array \"in1
7643         if (in1.length % 2 != 0) {
7644             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7646         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7648         ain1.copyFrom(in1);
7673     // in1 = "in", flattened 2-vectors
7674     public result_int reduce_my_short2_4(short[] in1) {
7675         // Verify that "in1" is non-null.
7676         if (in1 == null) {
7677             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7680         if (in1.length % 2 != 0) {
7681             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7683         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7685         ain1.copyFrom(in1);
7710     // in1 = "in", flattened 2-vectors
7711     public result_int reduce_my_short2_5(short[] in1) {
7712         // Verify that "in1" is non-null.
7713         if (in1 == null) {
7714             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7717         if (in1.length % 2 != 0) {
7718             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7720         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7722         ain1.copyFrom(in1);
7747     // in1 = "in", flattened 2-vectors
7748     public result_int reduce_my_short2_6(short[] in1) {
7749         // Verify that "in1" is non-null.
7750         if (in1 == null) {
7751             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7754         if (in1.length % 2 != 0) {
7755             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7757         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7759         ain1.copyFrom(in1);
7784     // in1 = "in", flattened 2-vectors
7785     public result_int reduce_my_short2_7(short[] in1) {
7786         // Verify that "in1" is non-null.
7787         if (in1 == null) {
7788             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7791         if (in1.length % 2 != 0) {
7792             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7794         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7796         ain1.copyFrom(in1);
7821     // in1 = "in", flattened 2-vectors
7822     public result_int reduce_my_short2_8(short[] in1) {
7823         // Verify that "in1" is non-null.
7824         if (in1 == null) {
7825             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7828         if (in1.length % 2 != 0) {
7829             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7831         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7833         ain1.copyFrom(in1);
7858     // in1 = "in", flattened 2-vectors
7859     public result_int reduce_my_short2_9(short[] in1) {
7860         // Verify that "in1" is non-null.
7861         if (in1 == null) {
7862             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7865         if (in1.length % 2 != 0) {
7866             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7868         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7870         ain1.copyFrom(in1);
7895     // in1 = "in", flattened 2-vectors
7896     public result_int reduce_my_short2_10(short[] in1) {
7897         // Verify that "in1" is non-null.
7898         if (in1 == null) {
7899             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7902         if (in1.length % 2 != 0) {
7903             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7905         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7907         ain1.copyFrom(in1);
7932     // in1 = "in", flattened 2-vectors
7933     public result_int reduce_my_short2_11(short[] in1) {
7934         // Verify that "in1" is non-null.
7935         if (in1 == null) {
7936             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7939         if (in1.length % 2 != 0) {
7940             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7942         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7944         ain1.copyFrom(in1);
7969     // in1 = "in", flattened 2-vectors
7970     public result_int reduce_my_short2_12(short[] in1) {
7971         // Verify that "in1" is non-null.
7972         if (in1 == null) {
7973             throw new RSIllegalArgumentException("Array \"in1\" is null!");
7976         if (in1.length % 2 != 0) {
7977             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
7979         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
7981         ain1.copyFrom(in1);
8006     // in1 = "in", flattened 2-vectors
8007     public result_int reduce_my_short2_13(short[] in1) {
8008         // Verify that "in1" is non-null.
8009         if (in1 == null) {
8010             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8013         if (in1.length % 2 != 0) {
8014             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
8016         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
8018         ain1.copyFrom(in1);
8043     // in1 = "in", flattened 2-vectors
8044     public result_int reduce_my_short2_14(short[] in1) {
8045         // Verify that "in1" is non-null.
8046         if (in1 == null) {
8047             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8050         if (in1.length % 2 != 0) {
8051 in1\" is not a multiple of 2 in length!");
8053         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
8055         ain1.copyFrom(in1);
8080     // in1 = "in", flattened 2-vectors
8081     public result_int reduce_my_short2_15(short[] in1) {
8082         // Verify that "in1" is non-null.
8083         if (in1 == null) {
8084             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8087         if (in1.length % 2 != 0) {
8088             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
8090         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_2, in1.length / 2);
8092         ain1.copyFrom(in1);
8117     // in1 = "in", flattened 4-vectors
8118     public result_int reduce_my_short4_0(short[] in1) {
8119         // Verify that "in1" is non-null.
8120         if (in1 == null) {
8121             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8124         if (in1.length % 4 != 0) {
8125             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8127         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8129         ain1.copyFrom(in1);
8154     // in1 = "in", flattened 4-vectors
8155     public result_int reduce_my_short4_1(short[] in1) {
8156         // Verify that "in1" is non-null.
8157         if (in1 == null) {
8158             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8161         if (in1.length % 4 != 0) {
8162             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8164         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8166         ain1.copyFrom(in1);
8191     // in1 = "in", flattened 4-vectors
8192     public result_int reduce_my_short4_2(short[] in1) {
8193         // Verify that "in1" is non-null.
8194         if (in1 == null) {
8195             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8198         if (in1.length % 4 != 0) {
8199             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8201         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8203         ain1.copyFrom(in1);
8228     // in1 = "in", flattened 4-vectors
8229     public result_int reduce_my_short4_3(short[] in1) {
8230         // Verify that "in1" is non-null.
8231         if (in1 == null) {
8232             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8235         if (in1.length % 4 != 0) {
8236             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8238         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8240         ain1.copyFrom(in1);
8265     // in1 = "in", flattened 4-vectors
8266     public result_int reduce_my_short4_4(short[] in1) {
8267         // Verify that "in1" is non-null.
8268         if (in1 == null) {
8269             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8272         if (in1.length % 4 != 0) {
8273             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8275         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8277         ain1.copyFrom(in1);
8302     // in1 = "in", flattened 4-vectors
8303     public result_int reduce_my_short4_5(short[] in1) {
8304         // Verify that "in1" is non-null.
8305         if (in1 == null) {
8306             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8309         if (in1.length % 4 != 0) {
8310             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8312         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8314         ain1.copyFrom(in1);
8339     // in1 = "in", flattened 4-vectors
8340     public result_int reduce_my_short4_6(short[] in1) {
8341         // Verify that "in1" is non-null.
8342         if (in1 == null) {
8343             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8346         if (in1.length % 4 != 0) {
8347             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8349         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8351         ain1.copyFrom(in1);
8376     // in1 = "in", flattened 4-vectors
8377     public result_int reduce_my_short4_7(short[] in1) {
8378         // Verify that "in1" is non-null.
8379         if (in1 == null) {
8380             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8383         if (in1.length % 4 != 0) {
8384             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8386         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8388         ain1.copyFrom(in1);
8413     // in1 = "in", flattened 4-vectors
8414     public result_int reduce_my_short4_8(short[] in1) {
8415         // Verify that "in1" is non-null.
8416         if (in1 == null) {
8417             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8420         if (in1.length % 4 != 0) {
8421             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8423         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8425         ain1.copyFrom(in1);
8450     // in1 = "in", flattened 4-vectors
8451     public result_int reduce_my_short4_9(short[] in1) {
8452         // Verify that "in1" is non-null.
8453         if (in1 == null) {
8454             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8457         if (in1.length % 4 != 0) {
8458             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8460         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1
8462         ain1.copyFrom(in1);
8487     // in1 = "in", flattened 4-vectors
8488     public result_int reduce_my_short4_10(short[] in1) {
8489         // Verify that "in1" is non-null.
8490         if (in1 == null) {
8491             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8494         if (in1.length % 4 != 0) {
8495             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8497         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8499         ain1.copyFrom(in1);
8524     // in1 = "in", flattened 4-vectors
8525     public result_int reduce_my_short4_11(short[] in1) {
8526         // Verify that "in1" is non-null.
8527         if (in1 == null) {
8528             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8531         if (in1.length % 4 != 0) {
8532             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8534         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8536         ain1.copyFrom(in1);
8561     // in1 = "in", flattened 4-vectors
8562     public result_int reduce_my_short4_12(short[] in1) {
8563         // Verify that "in1" is non-null.
8564         if (in1 == null) {
8565             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8568         if (in1.length % 4 != 0) {
8569             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8571         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8573         ain1.copyFrom(in1);
8598     // in1 = "in", flattened 4-vectors
8599     public result_int reduce_my_short4_13(short[] in1) {
8600         // Verify that "in1" is non-null.
8601         if (in1 == null) {
8602             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8605         if (in1.length % 4 != 0) {
8606             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8608         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8610         ain1.copyFrom(in1);
8635     // in1 = "in", flattened 4-vectors
8636     public result_int reduce_my_short4_14(short[] in1) {
8637         // Verify that "in1" is non-null.
8638         if (in1 == null) {
8639             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8642         if (in1.length % 4 != 0) {
8643             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8645         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8647         ain1.copyFrom(in1);
8672     // in1 = "in", flattened 4-vectors
8673     public result_int reduce_my_short4_15(short[] in1) {
8674         // Verify that "in1" is non-null.
8675         if (in1 == null) {
8676             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8679         if (in1.length % 4 != 0) {
8680             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
8682         Allocation ain1 = Allocation.createSized(mRSLocal, __I16_4, in1.length / 4);
8684         ain1.copyFrom(in1);
8709     // in1 = "in"
8710     public result_int reduce_my_int_0(int[] in1) {
8711         // Verify that "in1" is non-null.
8712         if (in1 == null) {
8713             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8715         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8717         ain1.copyFrom(in1);
8742     // in1 = "in"
8743     public result_int reduce_my_int_1(int[] in1) {
8744         // Verify that "in1" is non-null.
8745         if (in1 == null) {
8746             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8748         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8750         ain1.copyFrom(in1);
8775     // in1 = "in"
8776     public result_int reduce_my_int_2(int[] in1) {
8777         // Verify that "in1" is non-null.
8778         if (in1 == null) {
8779             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8781         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8783         ain1.copyFrom(in1);
8808     // in1 = "in"
8809     public result_int reduce_my_int_3(int[] in1) {
8810         // Verify that "in1" is non-null.
8811         if (in1 == null) {
8812             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8814         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8816         ain1.copyFrom(in1);
8841     // in1 = "in"
8842     public result_int reduce_my_int_4(int[] in1) {
8843         // Verify that "in1" is non-null.
8844         if (in1 == null) {
8845             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8847         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8849         ain1.copyFrom(in1);
8874     // in1 = "in"
8875     public result_int reduce_my_int_5(int[] in1) {
8876         // Verify that "in1" is non-null.
8877         if (in1 == null) {
8878             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8880         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8882         ain1.copyFrom(in1);
8907     // in1 = "in"
8908     public result_int reduce_my_int_6(int[] in1) {
8909         // Verify that "in1" is non-null.
8910         if (in1 == null) {
8911             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8913         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8915         ain1.copyFrom(in1);
8940     // in1 = "in"
8941     public result_int reduce_my_int_7(int[] in1) {
8942         // Verify that "in1" is non-null.
8943         if (in1 == null) {
8944             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8946         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8948         ain1.copyFrom(in1);
8973     // in1 = "in"
8974     public result_int reduce_my_int_8(int[] in1) {
8975         // Verify that "in1" is non-null.
8976         if (in1 == null) {
8977             throw new RSIllegalArgumentException("Array \"in1\" is null!");
8979         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
8981         ain1.copyFrom(in1);
9006     // in1 = "in"
9007     public result_int reduce_my_int_9(int[] in1) {
9008         // Verify that "in1" is non-null.
9009         if (in1 == null) {
9010             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9012         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
9014         ain1.copyFrom(in1);
9039     // in1 = "in"
9040     public result_int reduce_my_int_10(int[] in1) {
9041         // Verify that "in1" is non-null.
9042         if (in1 == null) {
9043             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9045         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
9047         ain1.copyFrom(in1);
9072     // in1 = "in"
9073     public result_int reduce_my_int_11(int[] in1) {
9074         // Verify that "in1" is non-null.
9075         if (in1 == null) {
9076             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9078         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
9080         ain1.copyFrom(in1);
9105     // in1 = "in"
9106     public result_int reduce_my_int_12(int[] in1) {
9107         // Verify that "in1" is non-null.
9108         if (in1 == null) {
9109             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9111         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
9113         ain1.copyFrom(in1);
9138     // in1 = "in"
9139     public result_int reduce_my_int_13(int[] in1) {
9140         // Verify that "in1" is non-null.
9141         if (in1 == null) {
9142             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9144         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
9146         ain1.copyFrom(in1);
9171     // in1 = "in"
9172     public result_int reduce_my_int_14(int[] in1) {
9173         // Verify that "in1" is non-null.
9174         if (in1 == null) {
9175             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9177         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
9179         ain1.copyFrom(in1);
9204     // in1 = "in"
9205     public result_int reduce_my_int_15(int[] in1) {
9206         // Verify that "in1" is non-null.
9207         if (in1 == null) {
9208             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9210         Allocation ain1 = Allocation.createSized(mRSLocal, __I32, in1.length);
9212         ain1.copyFrom(in1);
9237     // in1 = "in", flattened 2-vectors
9238     public result_int reduce_my_int2_0(int[] in1) {
9239         // Verify that "in1" is non-null.
9240         if (in1 == null) {
9241             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9244         if (in1.length % 2 != 0) {
9245             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9247         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9249         ain1.copyFrom(in1);
9274     // in1 = "in", flattened 2-vectors
9275     public result_int reduce_my_int2_1(int[] in1) {
9276         // Verify that "in1" is non-null.
9277         if (in1 == null) {
9278             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9281         if (in1.length % 2 != 0) {
9282             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9284         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9286         ain1.copyFrom(in1);
9311     // in1 = "in", flattened 2-vectors
9312     public result_int reduce_my_int2_2(int[] in1) {
9313         // Verify that "in1" is non-null.
9314         if (in1 == null) {
9315             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9318         if (in1.length % 2 != 0) {
9319             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9321         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9323         ain1.copyFrom(in1);
9348     // in1 = "in", flattened 2-vectors
9349     public result_int reduce_my_int2_3(int[] in1) {
9350         // Verify that "in1" is non-null.
9351         if (in1 == null) {
9352             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9355         if (in1.length % 2 != 0) {
9356             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9358         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9360         ain1.copyFrom(in1);
9385     // in1 = "in", flattened 2-vectors
9386     public result_int reduce_my_int2_4(int[] in1) {
9387         // Verify that "in1" is non-null.
9388         if (in1 == null) {
9389             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9392         if (in1.length % 2 != 0) {
9393             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9395         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9397         ain1.copyFrom(in1);
9422     // in1 = "in", flattened 2-vectors
9423     public result_int reduce_my_int2_5(int[] in1) {
9424         // Verify that "in1" is non-null.
9425         if (in1 == null) {
9426             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9429         if (in1.length % 2 != 0) {
9430             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9432         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9434         ain1.copyFrom(in1);
9459     // in1 = "in", flattened 2-vectors
9460     public result_int reduce_my_int2_6(int[] in1) {
9461         // Verify that "in1" is non-null.
9462         if (in1 == null) {
9463             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9466         if (in1.length % 2 != 0) {
9467             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9469         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9471         ain1.copyFrom(in1);
9496     // in1 = "in", flattened 2-vectors
9497     public result_int reduce_my_int2_7(int[] in1) {
9498         // Verify that "in1" is non-null.
9499         if (in1 == null) {
9500             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9503         if (in1.length % 2 != 0) {
9504             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9506         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9508         ain1.copyFrom(in1);
9533     // in1 = "in", flattened 2-vectors
9534     public result_int reduce_my_int2_8(int[] in1) {
9535         // Verify that "in1" is non-null.
9536         if (in1 == null) {
9537             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9540         if (in1.length % 2 != 0) {
9541             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9543         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9545         ain1.copyFrom(in1);
9570     // in1 = "in", flattened 2-vectors
9571     public result_int reduce_my_int2_9(int[] in1) {
9572         // Verify that "in1" is non-null.
9573         if (in1 == null) {
9574             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9577         if (in1.length % 2 != 0) {
9578             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9580         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9582         ain1.copyFrom(in1);
9607     // in1 = "in", flattened 2-vectors
9608     public result_int reduce_my_int2_10(int[] in1) {
9609         // Verify that "in1" is non-null.
9610         if (in1 == null) {
9611             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9614         if (in1.length % 2 != 0) {
9615             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9617         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9619         ain1.copyFrom(in1);
9644     // in1 = "in", flattened 2-vectors
9645     public result_int reduce_my_int2_11(int[] in1) {
9646         // Verify that "in1" is non-null.
9647         if (in1 == null) {
9648             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9651         if (in1.length % 2 != 0) {
9652             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9654         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9656         ain1.copyFrom(in1);
9681     // in1 = "in", flattened 2-vectors
9682     public result_int reduce_my_int2_12(int[] in1) {
9683         // Verify that "in1" is non-null.
9684         if (in1 == null) {
9685             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9688         if (in1.length % 2 != 0) {
9689             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9691         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9693         ain1.copyFrom(in1);
9718     // in1 = "in", flattened 2-vectors
9719     public result_int reduce_my_int2_13(int[] in1) {
9720         // Verify that "in1" is non-null.
9721         if (in1 == null) {
9722             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9725         if (in1.length % 2 != 0) {
9726             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9728         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9730         ain1.copyFrom(in1);
9755     // in1 = "in", flattened 2-vectors
9756     public result_int reduce_my_int2_14(int[] in1) {
9757         // Verify that "in1" is non-null.
9758         if (in1 == null) {
9759             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9762         if (in1.length % 2 != 0) {
9763             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9765         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9767         ain1.copyFrom(in1);
9792     // in1 = "in", flattened 2-vectors
9793     public result_int reduce_my_int2_15(int[] in1) {
9794         // Verify that "in1" is non-null.
9795         if (in1 == null) {
9796             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9799         if (in1.length % 2 != 0) {
9800             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
9802         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_2, in1.length / 2);
9804         ain1.copyFrom(in1);
9829     // in1 = "in", flattened 4-vectors
9830     public result_int reduce_my_int4_0(int[] in1) {
9831         // Verify that "in1" is non-null.
9832         if (in1 == null) {
9833             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9836         if (in1.length % 4 != 0) {
9837             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
9839         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
9841         ain1.copyFrom(in1);
9866     // in1 = "in", flattened 4-vectors
9867     public result_int reduce_my_int4_1(int[] in1) {
9868         // Verify that "in1" is non-null.
9869         if (in1 == null) {
9870             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9873         if (in1.length % 4 != 0) {
9874             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
9876         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
9878         ain1.copyFrom(in1);
9903     // in1 = "in", flattened 4-vectors
9904     public result_int reduce_my_int4_2(int[] in1) {
9905         // Verify that "in1" is non-null.
9906         if (in1 == null) {
9907             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9910         if (in1.length % 4 != 0) {
9911             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
9913         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
9915         ain1.copyFrom(in1);
9940     // in1 = "in", flattened 4-vectors
9941     public result_int reduce_my_int4_3(int[] in1) {
9942         // Verify that "in1" is non-null.
9943         if (in1 == null) {
9944             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9947         if (in1.length % 4 != 0) {
9948             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
9950         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
9952         ain1.copyFrom(in1);
9977     // in1 = "in", flattened 4-vectors
9978     public result_int reduce_my_int4_4(int[] in1) {
9979         // Verify that "in1" is non-null.
9980         if (in1 == null) {
9981             throw new RSIllegalArgumentException("Array \"in1\" is null!");
9984         if (in1.length % 4 != 0) {
9985             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
9987         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
9989         ain1.copyFrom(in1);
10014     // in1 = "in", flattened 4-vectors
10015     public result_int reduce_my_int4_5(int[] in1) {
10016         // Verify that "in1" is non-null.
10017         if (in1 == null) {
10018             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10021         if (in1.length % 4 != 0) {
10022             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10024         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10026         ain1.copyFrom(in1);
10051     // in1 = "in", flattened 4-vectors
10052     public result_int reduce_my_int4_6(int[] in1) {
10053         // Verify that "in1" is non-null.
10054         if (in1 == null) {
10055             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10058         if (in1.length % 4 != 0) {
10059             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10061         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10063         ain1.copyFrom(in1);
10088     // in1 = "in", flattened 4-vectors
10089     public result_int reduce_my_int4_7(int[] in1) {
10090         // Verify that "in1" is non-null.
10091         if (in1 == null) {
10092             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10095         if (in1.length % 4 != 0) {
10096             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10098         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10100         ain1.copyFrom(in1);
10125     // in1 = "in", flattened 4-vectors
10126     public result_int reduce_my_int4_8(int[] in1) {
10127         // Verify that "in1" is non-null.
10128         if (in1 == null) {
10129             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10132         if (in1.length % 4 != 0) {
10133             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10135         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10137         ain1.copyFrom(in1);
10162     // in1 = "in", flattened 4-vectors
10163     public result_int reduce_my_int4_9(int[] in1) {
10164         // Verify that "in1" is non-null.
10165         if (in1 == null) {
10166 in1\" is null!");
10169         if (in1.length % 4 != 0) {
10170             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10172         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10174         ain1.copyFrom(in1);
10199     // in1 = "in", flattened 4-vectors
10200     public result_int reduce_my_int4_10(int[] in1) {
10201         // Verify that "in1" is non-null.
10202         if (in1 == null) {
10203             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10206         if (in1.length % 4 != 0) {
10207             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10209         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10211         ain1.copyFrom(in1);
10236     // in1 = "in", flattened 4-vectors
10237     public result_int reduce_my_int4_11(int[] in1) {
10238         // Verify that "in1" is non-null.
10239         if (in1 == null) {
10240             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10243         if (in1.length % 4 != 0) {
10244             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10246         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10248         ain1.copyFrom(in1);
10273     // in1 = "in", flattened 4-vectors
10274     public result_int reduce_my_int4_12(int[] in1) {
10275         // Verify that "in1" is non-null.
10276         if (in1 == null) {
10277             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10280         if (in1.length % 4 != 0) {
10281             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10283         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10285         ain1.copyFrom(in1);
10310     // in1 = "in", flattened 4-vectors
10311     public result_int reduce_my_int4_13(int[] in1) {
10312         // Verify that "in1" is non-null.
10313         if (in1 == null) {
10314             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10317         if (in1.length % 4 != 0) {
10318             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10320         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10322         ain1.copyFrom(in1);
10347     // in1 = "in", flattened 4-vectors
10348     public result_int reduce_my_int4_14(int[] in1) {
10349         // Verify that "in1" is non-null.
10350         if (in1 == null) {
10351             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10354         if (in1.length % 4 != 0) {
10355             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10357         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10359         ain1.copyFrom(in1);
10384     // in1 = "in", flattened 4-vectors
10385     public result_int reduce_my_int4_15(int[] in1) {
10386         // Verify that "in1" is non-null.
10387         if (in1 == null) {
10388             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10391         if (in1.length % 4 != 0) {
10392             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
10394         Allocation ain1 = Allocation.createSized(mRSLocal, __I32_4, in1.length / 4);
10396         ain1.copyFrom(in1);
10421     // in1 = "in"
10422     public result_int reduce_my_long_0(long[] in1) {
10423         // Verify that "in1" is non-null.
10424         if (in1 == null) {
10425             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10427         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10429         ain1.copyFrom(in1);
10454     // in1 = "in"
10455     public result_int reduce_my_long_1(long[] in1) {
10456         // Verify that "in1" is non-null.
10457         if (in1 == null) {
10458             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10460         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10462         ain1.copyFrom(in1);
10487     // in1 = "in"
10488     public result_int reduce_my_long_2(long[] in1) {
10489         // Verify that "in1" is non-null.
10490         if (in1 == null) {
10491             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10493         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10495         ain1.copyFrom(in1);
10520     // in1 = "in"
10521     public result_int reduce_my_long_3(long[] in1) {
10522         // Verify that "in1" is non-null.
10523         if (in1 == null) {
10524             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10526         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10528         ain1.copyFrom(in1);
10553     // in1 = "in"
10554     public result_int reduce_my_long_4(long[] in1) {
10555         // Verify that "in1" is non-null.
10556         if (in1 == null) {
10557             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10559         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10561         ain1.copyFrom(in1);
10586     // in1 = "in"
10587     public result_int reduce_my_long_5(long[] in1) {
10588         // Verify that "in1" is non-null.
10589         if (in1 == null) {
10590             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10592         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10594         ain1.copyFrom(in1);
10619     // in1 = "in"
10620     public result_int reduce_my_long_6(long[] in1) {
10621         // Verify that "in1" is non-null.
10622         if (in1 == null) {
10623             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10625         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10627         ain1.copyFrom(in1);
10652     // in1 = "in"
10653     public result_int reduce_my_long_7(long[] in1) {
10654         // Verify that "in1" is non-null.
10655         if (in1 == null) {
10656             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10658         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10660         ain1.copyFrom(in1);
10685     // in1 = "in"
10686     public result_int reduce_my_long_8(long[] in1) {
10687         // Verify that "in1" is non-null.
10688         if (in1 == null) {
10689             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10691         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10693         ain1.copyFrom(in1);
10718     // in1 = "in"
10719     public result_int reduce_my_long_9(long[] in1) {
10720         // Verify that "in1" is non-null.
10721         if (in1 == null) {
10722             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10724         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10726         ain1.copyFrom(in1);
10751     // in1 = "in"
10752     public result_int reduce_my_long_10(long[] in1) {
10753         // Verify that "in1" is non-null.
10754         if (in1 == null) {
10755             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10757         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10759         ain1.copyFrom(in1);
10784     // in1 = "in"
10785     public result_int reduce_my_long_11(long[] in1) {
10786         // Verify that "in1" is non-null.
10787         if (in1 == null) {
10788             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10790         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10792         ain1.copyFrom(in1);
10817     // in1 = "in"
10818     public result_int reduce_my_long_12(long[] in1) {
10819         // Verify that "in1" is non-null.
10820         if (in1 == null) {
10821             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10823         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10825         ain1.copyFrom(in1);
10850     // in1 = "in"
10851     public result_int reduce_my_long_13(long[] in1) {
10852         // Verify that "in1" is non-null.
10853         if (in1 == null) {
10854             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10856         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10858         ain1.copyFrom(in1);
10883     // in1 = "in"
10884     public result_int reduce_my_long_14(long[] in1) {
10885         // Verify that "in1" is non-null.
10886         if (in1 == null) {
10887             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10889         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10891         ain1.copyFrom(in1);
10916     // in1 = "in"
10917     public result_int reduce_my_long_15(long[] in1) {
10918         // Verify that "in1" is non-null.
10919         if (in1 == null) {
10920             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10922         Allocation ain1 = Allocation.createSized(mRSLocal, __I64, in1.length);
10924         ain1.copyFrom(in1);
10949     // in1 = "in", flattened 2-vectors
10950     public result_int reduce_my_long2_0(long[] in1) {
10951         // Verify that "in1" is non-null.
10952         if (in1 == null) {
10953             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10956         if (in1.length % 2 != 0) {
10957             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
10959         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
10961         ain1.copyFrom(in1);
10986     // in1 = "in", flattened 2-vectors
10987     public result_int reduce_my_long2_1(long[] in1) {
10988         // Verify that "in1" is non-null.
10989         if (in1 == null) {
10990             throw new RSIllegalArgumentException("Array \"in1\" is null!");
10993         if (in1.length % 2 != 0) {
10994             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
10996         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
10998         ain1.copyFrom(in1);
11023     // in1 = "in", flattened 2-vectors
11024     public result_int reduce_my_long2_2(long[] in1) {
11025         // Verify that "in1" is non-null.
11026         if (in1 == null) {
11027             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11030         if (in1.length % 2 != 0) {
11031             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11033         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11035         ain1.copyFrom(in1);
11060     // in1 = "in", flattened 2-vectors
11061     public result_int reduce_my_long2_3(long[] in1) {
11062         // Verify that "in1" is non-null.
11063         if (in1 == null) {
11064             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11067         if (in1.length % 2 != 0) {
11068             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11070         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11072         ain1.copyFrom(in1);
11097     // in1 = "in", flattened 2-vectors
11098     public result_int reduce_my_long2_4(long[] in1) {
11099         // Verify that "in1" is non-null.
11100         if (in1 == null) {
11101             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11104         if (in1.length % 2 != 0) {
11105             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11107         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11109         ain1.copyFrom(in1);
11134     // in1 = "in", flattened 2-vectors
11135     public result_int reduce_my_long2_5(long[] in1) {
11136         // Verify that "in1" is non-null.
11137         if (in1 == null) {
11138             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11141         if (in1.length % 2 != 0) {
11142             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11144         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11146         ain1.copyFrom(in1);
11171     // in1 = "in", flattened 2-vectors
11172     public result_int reduce_my_long2_6(long[] in1) {
11173         // Verify that "in1" is non-null.
11174         if (in1 == null) {
11175             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11178         if (in1.length % 2 != 0) {
11179             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11181         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11183         ain1.copyFrom(in1);
11208     // in1 = "in", flattened 2-vectors
11209     public result_int reduce_my_long2_7(long[] in1) {
11210         // Verify that "in1" is non-null.
11211         if (in1 == null) {
11212             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11215         if (in1.length % 2 != 0) {
11216             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11218         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11220         ain1.copyFrom(in1);
11245     // in1 = "in", flattened 2-vectors
11246     public result_int reduce_my_long2_8(long[] in1) {
11247         // Verify that "in1" is non-null.
11248         if (in1 == null) {
11249             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11252         if (in1.length % 2 != 0) {
11253             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11255         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11257         ain1.copyFrom(in1);
11282     // in1 = "in", flattened 2-vectors
11283     public result_int reduce_my_long2_9(long[] in1) {
11284         // Verify that "in1" is non-null.
11285         if (in1 == null) {
11286             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11289         if (in1.length % 2 != 0) {
11290             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11292         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11294         ain1.copyFrom(in1);
11319     // in1 = "in", flattened 2-vectors
11320     public result_int reduce_my_long2_10(long[] in1) {
11321         // Verify that "in1" is non-null.
11322         if (in1 == null) {
11323             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11326         if (in1.length % 2 != 0) {
11327             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11329         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11331         ain1.copyFrom(in1);
11356     // in1 = "in", flattened 2-vectors
11357     public result_int reduce_my_long2_11(long[] in1) {
11358         // Verify that "in1" is non-null.
11359         if (in1 == null) {
11360             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11363         if (in1.length % 2 != 0) {
11364             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11366         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11368         ain1.copyFrom(in1);
11393     // in1 = "in", flattened 2-vectors
11394     public result_int reduce_my_long2_12(long[] in1) {
11395         // Verify that "in1" is non-null.
11396         if (in1 == null) {
11397             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11400         if (in1.length % 2 != 0) {
11401             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11403         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11405         ain1.copyFrom(in1);
11430     // in1 = "in", flattened 2-vectors
11431     public result_int reduce_my_long2_13(long[] in1) {
11432         // Verify that "in1" is non-null.
11433         if (in1 == null) {
11434             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11437         if (in1.length % 2 != 0) {
11438             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11440         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11442         ain1.copyFrom(in1);
11467     // in1 = "in", flattened 2-vectors
11468     public result_int reduce_my_long2_14(long[] in1) {
11469         // Verify that "in1" is non-null.
11470         if (in1 == null) {
11471             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11474         if (in1.length % 2 != 0) {
11475             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11477         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11479         ain1.copyFrom(in1);
11504     // in1 = "in", flattened 2-vectors
11505     public result_int reduce_my_long2_15(long[] in1) {
11506         // Verify that "in1" is non-null.
11507         if (in1 == null) {
11508             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11511         if (in1.length % 2 != 0) {
11512             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
11514         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_2, in1.length / 2);
11516         ain1.copyFrom(in1);
11541     // in1 = "in", flattened 4-vectors
11542     public result_int reduce_my_long4_0(long[] in1) {
11543         // Verify that "in1" is non-null.
11544         if (in1 == null) {
11545             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11548         if (in1.length % 4 != 0) {
11549             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11551         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11553         ain1.copyFrom(in1);
11578     // in1 = "in", flattened 4-vectors
11579     public result_int reduce_my_long4_1(long[] in1) {
11580         // Verify that "in1" is non-null.
11581         if (in1 == null) {
11582             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11585         if (in1.length % 4 != 0) {
11586             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11588         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11590         ain1.copyFrom(in1);
11615     // in1 = "in", flattened 4-vectors
11616     public result_int reduce_my_long4_2(long[] in1) {
11617         // Verify that "in1" is non-null.
11618         if (in1 == null) {
11619             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11622         if (in1.length % 4 != 0) {
11623             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11625         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11627         ain1.copyFrom(in1);
11652     // in1 = "in", flattened 4-vectors
11653     public result_int reduce_my_long4_3(long[] in1) {
11654         // Verify that "in1" is non-null.
11655         if (in1 == null) {
11656             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11659         if (in1.length % 4 != 0) {
11660             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11662         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11664         ain1.copyFrom(in1);
11689     // in1 = "in", flattened 4-vectors
11690     public result_int reduce_my_long4_4(long[] in1) {
11691         // Verify that "in1" is non-null.
11692         if (in1 == null) {
11693             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11696         if (in1.length % 4 != 0) {
11697             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11699         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11701         ain1.copyFrom(in1);
11726     // in1 = "in", flattened 4-vectors
11727     public result_int reduce_my_long4_5(long[] in1) {
11728         // Verify that "in1" is non-null.
11729         if (in1 == null) {
11730             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11733         if (in1.length % 4 != 0) {
11734             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11736         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11738         ain1.copyFrom(in1);
11763     // in1 = "in", flattened 4-vectors
11764     public result_int reduce_my_long4_6(long[] in1) {
11765         // Verify that "in1" is non-null.
11766         if (in1 == null) {
11767             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11770         if (in1.length % 4 != 0) {
11771             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11773         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11775         ain1.copyFrom(in1);
11800     // in1 = "in", flattened 4-vectors
11801     public result_int reduce_my_long4_7(long[] in1) {
11802         // Verify that "in1" is non-null.
11803         if (in1 == null) {
11804             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11807         if (in1.length % 4 != 0) {
11808             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11810         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11812         ain1.copyFrom(in1);
11837     // in1 = "in", flattened 4-vectors
11838     public result_int reduce_my_long4_8(long[] in1) {
11839         // Verify that "in1" is non-null.
11840         if (in1 == null) {
11841             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11844         if (in1.length % 4 != 0) {
11845             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11847         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11849         ain1.copyFrom(in1);
11874     // in1 = "in", flattened 4-vectors
11875     public result_int reduce_my_long4_9(long[] in1) {
11876         // Verify that "in1" is non-null.
11877         if (in1 == null) {
11878             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11881         if (in1.length % 4 != 0) {
11882             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11884         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11886         ain1.copyFrom(in1);
11911     // in1 = "in", flattened 4-vectors
11912     public result_int reduce_my_long4_10(long[] in1) {
11913         // Verify that "in1" is non-null.
11914         if (in1 == null) {
11915             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11918         if (in1.length % 4 != 0) {
11919             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11921         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11923         ain1.copyFrom(in1);
11948     // in1 = "in", flattened 4-vectors
11949     public result_int reduce_my_long4_11(long[] in1) {
11950         // Verify that "in1" is non-null.
11951         if (in1 == null) {
11952             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11955         if (in1.length % 4 != 0) {
11956             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11958         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11960         ain1.copyFrom(in1);
11985     // in1 = "in", flattened 4-vectors
11986     public result_int reduce_my_long4_12(long[] in1) {
11987         // Verify that "in1" is non-null.
11988         if (in1 == null) {
11989             throw new RSIllegalArgumentException("Array \"in1\" is null!");
11992         if (in1.length % 4 != 0) {
11993             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
11995         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
11997         ain1.copyFrom(in1);
12022     // in1 = "in", flattened 4-vectors
12023     public result_int reduce_my_long4_13(long[] in1) {
12024         // Verify that "in1" is non-null.
12025         if (in1 == null) {
12026             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12029         if (in1.length % 4 != 0) {
12030             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
12032         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
12034         ain1.copyFrom(in1);
12059     // in1 = "in", flattened 4-vectors
12060     public result_int reduce_my_long4_14(long[] in1) {
12061         // Verify that "in1" is non-null.
12062         if (in1 == null) {
12063             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12066         if (in1.length % 4 != 0) {
12067             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
12069         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
12071         ain1.copyFrom(in1);
12096     // in1 = "in", flattened 4-vectors
12097     public result_int reduce_my_long4_15(long[] in1) {
12098         // Verify that "in1" is non-null.
12099         if (in1 == null) {
12100             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12103         if (in1.length % 4 != 0) {
12104             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
12106         Allocation ain1 = Allocation.createSized(mRSLocal, __I64_4, in1.length / 4);
12108         ain1.copyFrom(in1);
12133     // in1 = "in"
12134     public result_int reduce_my_uchar_0(byte[] in1) {
12135         // Verify that "in1" is non-null.
12136         if (in1 == null) {
12137             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12139         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12141         ain1.copyFrom(in1);
12166     // in1 = "in"
12167     public result_int reduce_my_uchar_1(byte[] in1) {
12168         // Verify that "in1" is non-null.
12169         if (in1 == null) {
12170             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12172         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12174         ain1.copyFrom(in1);
12199     // in1 = "in"
12200     public result_int reduce_my_uchar_2(byte[] in1) {
12201         // Verify that "in1" is non-null.
12202         if (in1 == null) {
12203             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12205         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12207         ain1.copyFrom(in1);
12232     // in1 = "in"
12233     public result_int reduce_my_uchar_3(byte[] in1) {
12234         // Verify that "in1" is non-null.
12235         if (in1 == null) {
12236             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12238         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12240         ain1.copyFrom(in1);
12265     // in1 = "in"
12266     public result_int reduce_my_uchar_4(byte[] in1) {
12267         // Verify that "in1" is non-null.
12268         if (in1 == null) {
12269             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12271         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12273         ain1.copyFrom(in1);
12298     // in1 = "in"
12299     public result_int reduce_my_uchar_5(byte[] in1) {
12300         // Verify that "in1" is non-null.
12301         if (in1 == null) {
12302             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12304         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12306         ain1.copyFrom(in1);
12331     // in1 = "in"
12332     public result_int reduce_my_uchar_6(byte[] in1) {
12333         // Verify that "in1" is non-null.
12334         if (in1 == null) {
12335             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12337         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12339         ain1.copyFrom(in1);
12364     // in1 = "in"
12365     public result_int reduce_my_uchar_7(byte[] in1) {
12366         // Verify that "in1" is non-null.
12367         if (in1 == null) {
12368             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12370         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12372         ain1.copyFrom(in1);
12397     // in1 = "in"
12398     public result_int reduce_my_uchar_8(byte[] in1) {
12399         // Verify that "in1" is non-null.
12400         if (in1 == null) {
12401             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12403         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12405         ain1.copyFrom(in1);
12430     // in1 = "in"
12431     public result_int reduce_my_uchar_9(byte[] in1) {
12432         // Verify that "in1" is non-null.
12433         if (in1 == null) {
12434             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12436         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12438         ain1.copyFrom(in1);
12463     // in1 = "in"
12464     public result_int reduce_my_uchar_10(byte[] in1) {
12465         // Verify that "in1" is non-null.
12466         if (in1 == null) {
12467             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12469         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12471         ain1.copyFrom(in1);
12496     // in1 = "in"
12497     public result_int reduce_my_uchar_11(byte[] in1) {
12498         // Verify that "in1" is non-null.
12499         if (in1 == null) {
12500             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12502         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12504         ain1.copyFrom(in1);
12529     // in1 = "in"
12530     public result_int reduce_my_uchar_12(byte[] in1) {
12531         // Verify that "in1" is non-null.
12532         if (in1 == null) {
12533             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12535         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12537         ain1.copyFrom(in1);
12562     // in1 = "in"
12563     public result_int reduce_my_uchar_13(byte[] in1) {
12564         // Verify that "in1" is non-null.
12565         if (in1 == null) {
12566             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12568         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12570         ain1.copyFrom(in1);
12595     // in1 = "in"
12596     public result_int reduce_my_uchar_14(byte[] in1) {
12597         // Verify that "in1" is non-null.
12598         if (in1 == null) {
12599             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12601         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12603         ain1.copyFrom(in1);
12628     // in1 = "in"
12629     public result_int reduce_my_uchar_15(byte[] in1) {
12630         // Verify that "in1" is non-null.
12631         if (in1 == null) {
12632             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12634         Allocation ain1 = Allocation.createSized(mRSLocal, __U8, in1.length);
12636         ain1.copyFrom(in1);
12661     // in1 = "in", flattened 2-vectors
12662     public result_int reduce_my_uchar2_0(byte[] in1) {
12663         // Verify that "in1" is non-null.
12664         if (in1 == null) {
12665             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12668         if (in1.length % 2 != 0) {
12669             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12671         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12673         ain1.copyFrom(in1);
12698     // in1 = "in", flattened 2-vectors
12699     public result_int reduce_my_uchar2_1(byte[] in1) {
12700         // Verify that "in1" is non-null.
12701         if (in1 == null) {
12702             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12705         if (in1.length % 2 != 0) {
12706             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12708         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12710         ain1.copyFrom(in1);
12735     // in1 = "in", flattened 2-vectors
12736     public result_int reduce_my_uchar2_2(byte[] in1) {
12737         // Verify that "in1" is non-null.
12738         if (in1 == null) {
12739             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12742         if (in1.length % 2 != 0) {
12743             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12745         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12747         ain1.copyFrom(in1);
12772     // in1 = "in", flattened 2-vectors
12773     public result_int reduce_my_uchar2_3(byte[] in1) {
12774         // Verify that "in1" is non-null.
12775         if (in1 == null) {
12776             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12779         if (in1.length % 2 != 0) {
12780             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12782         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12784         ain1.copyFrom(in1);
12809     // in1 = "in", flattened 2-vectors
12810     public result_int reduce_my_uchar2_4(byte[] in1) {
12811         // Verify that "in1" is non-null.
12812         if (in1 == null) {
12813             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12816         if (in1.length % 2 != 0) {
12817             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12819         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12821         ain1.copyFrom(in1);
12846     // in1 = "in", flattened 2-vectors
12847     public result_int reduce_my_uchar2_5(byte[] in1) {
12848         // Verify that "in1" is non-null.
12849         if (in1 == null) {
12850             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12853         if (in1.length % 2 != 0) {
12854             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12856         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12858         ain1.copyFrom(in1);
12883     // in1 = "in", flattened 2-vectors
12884     public result_int reduce_my_uchar2_6(byte[] in1) {
12885         // Verify that "in1" is non-null.
12886         if (in1 == null) {
12887             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12890         if (in1.length % 2 != 0) {
12891             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12893         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12895         ain1.copyFrom(in1);
12920     // in1 = "in", flattened 2-vectors
12921     public result_int reduce_my_uchar2_7(byte[] in1) {
12922         // Verify that "in1" is non-null.
12923         if (in1 == null) {
12924             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12927         if (in1.length % 2 != 0) {
12928             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12930         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12932         ain1.copyFrom(in1);
12957     // in1 = "in", flattened 2-vectors
12958     public result_int reduce_my_uchar2_8(byte[] in1) {
12959         // Verify that "in1" is non-null.
12960         if (in1 == null) {
12961             throw new RSIllegalArgumentException("Array \"in1\" is null!");
12964         if (in1.length % 2 != 0) {
12965             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
12967         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
12969         ain1.copyFrom(in1);
12994     // in1 = "in", flattened 2-vectors
12995     public result_int reduce_my_uchar2_9(byte[] in1) {
12996         // Verify that "in1" is non-null.
12997         if (in1 == null) {
12998             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13001         if (in1.length % 2 != 0) {
13002             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
13004         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
13006         ain1.copyFrom(in1);
13031     // in1 = "in", flattened 2-vectors
13032     public result_int reduce_my_uchar2_10(byte[] in1) {
13033         // Verify that "in1" is non-null.
13034         if (in1 == null) {
13035             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13038         if (in1.length % 2 != 0) {
13039             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
13041         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
13043         ain1.copyFrom(in1);
13068     // in1 = "in", flattened 2-vectors
13069     public result_int reduce_my_uchar2_11(byte[] in1) {
13070         // Verify that "in1" is non-null.
13071         if (in1 == null) {
13072             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13075         if (in1.length % 2 != 0) {
13076             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
13078         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
13080         ain1.copyFrom(in1);
13105     // in1 = "in", flattened 2-vectors
13106     public result_int reduce_my_uchar2_12(byte[] in1) {
13107         // Verify that "in1" is non-null.
13108         if (in1 == null) {
13109             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13112         if (in1.length % 2 != 0) {
13113             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
13115         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
13117         ain1.copyFrom(in1);
13142     // in1 = "in", flattened 2-vectors
13143     public result_int reduce_my_uchar2_13(byte[] in1) {
13144         // Verify that "in1" is non-null.
13145         if (in1 == null) {
13146             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13149         if (in1.length % 2 != 0) {
13150             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
13152         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
13154         ain1.copyFrom(in1);
13179     // in1 = "in", flattened 2-vectors
13180     public result_int reduce_my_uchar2_14(byte[] in1) {
13181         // Verify that "in1" is non-null.
13182         if (in1 == null) {
13183             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13186         if (in1.length % 2 != 0) {
13187             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
13189         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
13191         ain1.copyFrom(in1);
13216     // in1 = "in", flattened 2-vectors
13217     public result_int reduce_my_uchar2_15(byte[] in1) {
13218         // Verify that "in1" is non-null.
13219         if (in1 == null) {
13220             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13223         if (in1.length % 2 != 0) {
13224             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
13226         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_2, in1.length / 2);
13228         ain1.copyFrom(in1);
13253     // in1 = "in", flattened 4-vectors
13254     public result_int reduce_my_uchar4_0(byte[] in1) {
13255         // Verify that "in1" is non-null.
13256         if (in1 == null) {
13257             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13260         if (in1.length % 4 != 0) {
13261             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13263         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13265         ain1.copyFrom(in1);
13290     // in1 = "in", flattened 4-vectors
13291     public result_int reduce_my_uchar4_1(byte[] in1) {
13292         // Verify that "in1" is non-null.
13293         if (in1 == null) {
13294             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13297         if (in1.length % 4 != 0) {
13298             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13300         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13302         ain1.copyFrom(in1);
13327     // in1 = "in", flattened 4-vectors
13328     public result_int reduce_my_uchar4_2(byte[] in1) {
13329         // Verify that "in1" is non-null.
13330         if (in1 == null) {
13331             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13334         if (in1.length % 4 != 0) {
13335             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13337         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13339         ain1.copyFrom(in1);
13364     // in1 = "in", flattened 4-vectors
13365     public result_int reduce_my_uchar4_3(byte[] in1) {
13366         // Verify that "in1" is non-null.
13367         if (in1 == null) {
13368             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13371         if (in1.length % 4 != 0) {
13372             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13374         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13376         ain1.copyFrom(in1);
13401     // in1 = "in", flattened 4-vectors
13402     public result_int reduce_my_uchar4_4(byte[] in1) {
13403         // Verify that "in1" is non-null.
13404         if (in1 == null) {
13405             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13408         if (in1.length % 4 != 0) {
13409             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13411         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13413         ain1.copyFrom(in1);
13438     // in1 = "in", flattened 4-vectors
13439     public result_int reduce_my_uchar4_5(byte[] in1) {
13440         // Verify that "in1" is non-null.
13441         if (in1 == null) {
13442             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13445         if (in1.length % 4 != 0) {
13446             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13448         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13450         ain1.copyFrom(in1);
13475     // in1 = "in", flattened 4-vectors
13476     public result_int reduce_my_uchar4_6(byte[] in1) {
13477         // Verify that "in1" is non-null.
13478         if (in1 == null) {
13479             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13482         if (in1.length % 4 != 0) {
13483             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13485         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13487         ain1.copyFrom(in1);
13512     // in1 = "in", flattened 4-vectors
13513     public result_int reduce_my_uchar4_7(byte[] in1) {
13514         // Verify that "in1" is non-null.
13515         if (in1 == null) {
13516             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13519         if (in1.length % 4 != 0) {
13520             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13522         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13524         ain1.copyFrom(in1);
13549     // in1 = "in", flattened 4-vectors
13550     public result_int reduce_my_uchar4_8(byte[] in1) {
13551         // Verify that "in1" is non-null.
13552         if (in1
13553             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13556         if (in1.length % 4 != 0) {
13557             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13559         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13561         ain1.copyFrom(in1);
13586     // in1 = "in", flattened 4-vectors
13587     public result_int reduce_my_uchar4_9(byte[] in1) {
13588         // Verify that "in1" is non-null.
13589         if (in1 == null) {
13590             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13593         if (in1.length % 4 != 0) {
13594             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13596         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13598         ain1.copyFrom(in1);
13623     // in1 = "in", flattened 4-vectors
13624     public result_int reduce_my_uchar4_10(byte[] in1) {
13625         // Verify that "in1" is non-null.
13626         if (in1 == null) {
13627             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13630         if (in1.length % 4 != 0) {
13631             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13633         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13635         ain1.copyFrom(in1);
13660     // in1 = "in", flattened 4-vectors
13661     public result_int reduce_my_uchar4_11(byte[] in1) {
13662         // Verify that "in1" is non-null.
13663         if (in1 == null) {
13664             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13667         if (in1.length % 4 != 0) {
13668             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13670         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13672         ain1.copyFrom(in1);
13697     // in1 = "in", flattened 4-vectors
13698     public result_int reduce_my_uchar4_12(byte[] in1) {
13699         // Verify that "in1" is non-null.
13700         if (in1 == null) {
13701             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13704         if (in1.length % 4 != 0) {
13705             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13707         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13709         ain1.copyFrom(in1);
13734     // in1 = "in", flattened 4-vectors
13735     public result_int reduce_my_uchar4_13(byte[] in1) {
13736         // Verify that "in1" is non-null.
13737         if (in1 == null) {
13738             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13741         if (in1.length % 4 != 0) {
13742             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13744         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13746         ain1.copyFrom(in1);
13771     // in1 = "in", flattened 4-vectors
13772     public result_int reduce_my_uchar4_14(byte[] in1) {
13773         // Verify that "in1" is non-null.
13774         if (in1 == null) {
13775             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13778         if (in1.length % 4 != 0) {
13779             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13781         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13783         ain1.copyFrom(in1);
13808     // in1 = "in", flattened 4-vectors
13809     public result_int reduce_my_uchar4_15(byte[] in1) {
13810         // Verify that "in1" is non-null.
13811         if (in1 == null) {
13812             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13815         if (in1.length % 4 != 0) {
13816             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
13818         Allocation ain1 = Allocation.createSized(mRSLocal, __U8_4, in1.length / 4);
13820         ain1.copyFrom(in1);
13845     // in1 = "in"
13846     public result_int reduce_my_ushort_0(short[] in1) {
13847         // Verify that "in1" is non-null.
13848         if (in1 == null) {
13849             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13851         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
13853         ain1.copyFrom(in1);
13878     // in1 = "in"
13879     public result_int reduce_my_ushort_1(short[] in1) {
13880         // Verify that "in1" is non-null.
13881         if (in1 == null) {
13882             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13884         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
13886         ain1.copyFrom(in1);
13911     // in1 = "in"
13912     public result_int reduce_my_ushort_2(short[] in1) {
13913         // Verify that "in1" is non-null.
13914         if (in1 == null) {
13915             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13917         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
13919         ain1.copyFrom(in1);
13944     // in1 = "in"
13945     public result_int reduce_my_ushort_3(short[] in1) {
13946         // Verify that "in1" is non-null.
13947         if (in1 == null) {
13948             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13950         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
13952         ain1.copyFrom(in1);
13977     // in1 = "in"
13978     public result_int reduce_my_ushort_4(short[] in1) {
13979         // Verify that "in1" is non-null.
13980         if (in1 == null) {
13981             throw new RSIllegalArgumentException("Array \"in1\" is null!");
13983         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
13985         ain1.copyFrom(in1);
14010     // in1 = "in"
14011     public result_int reduce_my_ushort_5(short[] in1) {
14012         // Verify that "in1" is non-null.
14013         if (in1 == null) {
14014             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14016         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14018         ain1.copyFrom(in1);
14043     // in1 = "in"
14044     public result_int reduce_my_ushort_6(short[] in1) {
14045         // Verify that "in1" is non-null.
14046         if (in1 == null) {
14047             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14049         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14051         ain1.copyFrom(in1);
14076     // in1 = "in"
14077     public result_int reduce_my_ushort_7(short[] in1) {
14078         // Verify that "in1" is non-null.
14079         if (in1 == null) {
14080             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14082         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14084         ain1.copyFrom(in1);
14109     // in1 = "in"
14110     public result_int reduce_my_ushort_8(short[] in1) {
14111         // Verify that "in1" is non-null.
14112         if (in1 == null) {
14113             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14115         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14117         ain1.copyFrom(in1);
14142     // in1 = "in"
14143     public result_int reduce_my_ushort_9(short[] in1) {
14144         // Verify that "in1" is non-null.
14145         if (in1 == null) {
14146             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14148         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14150         ain1.copyFrom(in1);
14175     // in1 = "in"
14176     public result_int reduce_my_ushort_10(short[] in1) {
14177         // Verify that "in1" is non-null.
14178         if (in1 == null) {
14179             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14181         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14183         ain1.copyFrom(in1);
14208     // in1 = "in"
14209     public result_int reduce_my_ushort_11(short[] in1) {
14210         // Verify that "in1" is non-null.
14211         if (in1 == null) {
14212             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14214         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14216         ain1.copyFrom(in1);
14241     // in1 = "in"
14242     public result_int reduce_my_ushort_12(short[] in1) {
14243         // Verify that "in1" is non-null.
14244         if (in1 == null) {
14245             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14247         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14249         ain1.copyFrom(in1);
14274     // in1 = "in"
14275     public result_int reduce_my_ushort_13(short[] in1) {
14276         // Verify that "in1" is non-null.
14277         if (in1 == null) {
14278             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14280         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14282         ain1.copyFrom(in1);
14307     // in1 = "in"
14308     public result_int reduce_my_ushort_14(short[] in1) {
14309         // Verify that "in1" is non-null.
14310         if (in1 == null) {
14311             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14313         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14315         ain1.copyFrom(in1);
14340     // in1 = "in"
14341     public result_int reduce_my_ushort_15(short[] in1) {
14342         // Verify that "in1" is non-null.
14343         if (in1 == null) {
14344             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14346         Allocation ain1 = Allocation.createSized(mRSLocal, __U16, in1.length);
14348         ain1.copyFrom(in1);
14373     // in1 = "in", flattened 2-vectors
14374     public result_int reduce_my_ushort2_0(short[] in1) {
14375         // Verify that "in1" is non-null.
14376         if (in1 == null) {
14377             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14380         if (in1.length % 2 != 0) {
14381             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14383         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14385         ain1.copyFrom(in1);
14410     // in1 = "in", flattened 2-vectors
14411 in1) {
14412         // Verify that "in1" is non-null.
14413         if (in1 == null) {
14414             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14417         if (in1.length % 2 != 0) {
14418             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14420         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14422         ain1.copyFrom(in1);
14447     // in1 = "in", flattened 2-vectors
14448     public result_int reduce_my_ushort2_2(short[] in1) {
14449         // Verify that "in1" is non-null.
14450         if (in1 == null) {
14451             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14454         if (in1.length % 2 != 0) {
14455             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14457         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14459         ain1.copyFrom(in1);
14484     // in1 = "in", flattened 2-vectors
14485     public result_int reduce_my_ushort2_3(short[] in1) {
14486         // Verify that "in1" is non-null.
14487         if (in1 == null) {
14488             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14491         if (in1.length % 2 != 0) {
14492             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14494         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14496         ain1.copyFrom(in1);
14521     // in1 = "in", flattened 2-vectors
14522     public result_int reduce_my_ushort2_4(short[] in1) {
14523         // Verify that "in1" is non-null.
14524         if (in1 == null) {
14525             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14528         if (in1.length % 2 != 0) {
14529             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14531         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14533         ain1.copyFrom(in1);
14558     // in1 = "in", flattened 2-vectors
14559     public result_int reduce_my_ushort2_5(short[] in1) {
14560         // Verify that "in1" is non-null.
14561         if (in1 == null) {
14562             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14565         if (in1.length % 2 != 0) {
14566             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14568         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14570         ain1.copyFrom(in1);
14595     // in1 = "in", flattened 2-vectors
14596     public result_int reduce_my_ushort2_6(short[] in1) {
14597         // Verify that "in1" is non-null.
14598         if (in1 == null) {
14599             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14602         if (in1.length % 2 != 0) {
14603             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14605         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14607         ain1.copyFrom(in1);
14632     // in1 = "in", flattened 2-vectors
14633     public result_int reduce_my_ushort2_7(short[] in1) {
14634         // Verify that "in1" is non-null.
14635         if (in1 == null) {
14636             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14639         if (in1.length % 2 != 0) {
14640             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14642         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14644         ain1.copyFrom(in1);
14669     // in1 = "in", flattened 2-vectors
14670     public result_int reduce_my_ushort2_8(short[] in1) {
14671         // Verify that "in1" is non-null.
14672         if (in1 == null) {
14673             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14676         if (in1.length % 2 != 0) {
14677             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14679         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14681         ain1.copyFrom(in1);
14706     // in1 = "in", flattened 2-vectors
14707     public result_int reduce_my_ushort2_9(short[] in1) {
14708         // Verify that "in1" is non-null.
14709         if (in1 == null) {
14710             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14713         if (in1.length % 2 != 0) {
14714             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14716         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14718         ain1.copyFrom(in1);
14743     // in1 = "in", flattened 2-vectors
14744     public result_int reduce_my_ushort2_10(short[] in1) {
14745         // Verify that "in1" is non-null.
14746         if (in1 == null) {
14747             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14750         if (in1.length % 2 != 0) {
14751             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14753         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14755         ain1.copyFrom(in1);
14780     // in1 = "in", flattened 2-vectors
14781     public result_int reduce_my_ushort2_11(short[] in1) {
14782         // Verify that "in1" is non-null.
14783         if (in1 == null) {
14784             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14787         if (in1.length % 2 != 0) {
14788             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14790         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14792         ain1.copyFrom(in1);
14817     // in1 = "in", flattened 2-vectors
14818     public result_int reduce_my_ushort2_12(short[] in1) {
14819 in1" is non-null.
14820         if (in1 == null) {
14821             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14824         if (in1.length % 2 != 0) {
14825             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14827         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14829         ain1.copyFrom(in1);
14854     // in1 = "in", flattened 2-vectors
14855     public result_int reduce_my_ushort2_13(short[] in1) {
14856         // Verify that "in1" is non-null.
14857         if (in1 == null) {
14858             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14861         if (in1.length % 2 != 0) {
14862             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14864         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14866         ain1.copyFrom(in1);
14891     // in1 = "in", flattened 2-vectors
14892     public result_int reduce_my_ushort2_14(short[] in1) {
14893         // Verify that "in1" is non-null.
14894         if (in1 == null) {
14895             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14898         if (in1.length % 2 != 0) {
14899             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14901         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14903         ain1.copyFrom(in1);
14928     // in1 = "in", flattened 2-vectors
14929     public result_int reduce_my_ushort2_15(short[] in1) {
14930         // Verify that "in1" is non-null.
14931         if (in1 == null) {
14932             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14935         if (in1.length % 2 != 0) {
14936             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
14938         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_2, in1.length / 2);
14940         ain1.copyFrom(in1);
14965     // in1 = "in", flattened 4-vectors
14966     public result_int reduce_my_ushort4_0(short[] in1) {
14967         // Verify that "in1" is non-null.
14968         if (in1 == null) {
14969             throw new RSIllegalArgumentException("Array \"in1\" is null!");
14972         if (in1.length % 4 != 0) {
14973             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
14975         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
14977         ain1.copyFrom(in1);
15002     // in1 = "in", flattened 4-vectors
15003     public result_int reduce_my_ushort4_1(short[] in1) {
15004         // Verify that "in1" is non-null.
15005         if (in1 == null) {
15006             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15009         if (in1.length % 4 != 0) {
15010             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15012         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15014         ain1.copyFrom(in1);
15039     // in1 = "in", flattened 4-vectors
15040     public result_int reduce_my_ushort4_2(short[] in1) {
15041         // Verify that "in1" is non-null.
15042         if (in1 == null) {
15043             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15046         if (in1.length % 4 != 0) {
15047             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15049         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15051         ain1.copyFrom(in1);
15076     // in1 = "in", flattened 4-vectors
15077     public result_int reduce_my_ushort4_3(short[] in1) {
15078         // Verify that "in1" is non-null.
15079         if (in1 == null) {
15080             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15083         if (in1.length % 4 != 0) {
15084             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15086         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15088         ain1.copyFrom(in1);
15113     // in1 = "in", flattened 4-vectors
15114     public result_int reduce_my_ushort4_4(short[] in1) {
15115         // Verify that "in1" is non-null.
15116         if (in1 == null) {
15117             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15120         if (in1.length % 4 != 0) {
15121             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15123         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15125         ain1.copyFrom(in1);
15150     // in1 = "in", flattened 4-vectors
15151     public result_int reduce_my_ushort4_5(short[] in1) {
15152         // Verify that "in1" is non-null.
15153         if (in1 == null) {
15154             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15157         if (in1.length % 4 != 0) {
15158             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15160         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15162         ain1.copyFrom(in1);
15187     // in1 = "in", flattened 4-vectors
15188     public result_int reduce_my_ushort4_6(short[] in1) {
15189         // Verify that "in1" is non-null.
15190         if (in1 == null) {
15191             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15194         if (in1.length % 4 != 0) {
15195             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15197         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15199         ain1.copyFrom(in1);
15224     // in1 = "in", flattened 4-vectors
15225     public result_int reduce_my_ushort4_7(short[] in1) {
15226         // Verify that "in1" is non-null.
15227         if (in1 == null) {
15228 in1\" is null!");
15231         if (in1.length % 4 != 0) {
15232             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15234         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15236         ain1.copyFrom(in1);
15261     // in1 = "in", flattened 4-vectors
15262     public result_int reduce_my_ushort4_8(short[] in1) {
15263         // Verify that "in1" is non-null.
15264         if (in1 == null) {
15265             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15268         if (in1.length % 4 != 0) {
15269             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15271         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15273         ain1.copyFrom(in1);
15298     // in1 = "in", flattened 4-vectors
15299     public result_int reduce_my_ushort4_9(short[] in1) {
15300         // Verify that "in1" is non-null.
15301         if (in1 == null) {
15302             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15305         if (in1.length % 4 != 0) {
15306             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15308         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15310         ain1.copyFrom(in1);
15335     // in1 = "in", flattened 4-vectors
15336     public result_int reduce_my_ushort4_10(short[] in1) {
15337         // Verify that "in1" is non-null.
15338         if (in1 == null) {
15339             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15342         if (in1.length % 4 != 0) {
15343             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15345         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15347         ain1.copyFrom(in1);
15372     // in1 = "in", flattened 4-vectors
15373     public result_int reduce_my_ushort4_11(short[] in1) {
15374         // Verify that "in1" is non-null.
15375         if (in1 == null) {
15376             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15379         if (in1.length % 4 != 0) {
15380             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15382         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15384         ain1.copyFrom(in1);
15409     // in1 = "in", flattened 4-vectors
15410     public result_int reduce_my_ushort4_12(short[] in1) {
15411         // Verify that "in1" is non-null.
15412         if (in1 == null) {
15413             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15416         if (in1.length % 4 != 0) {
15417             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15419         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15421         ain1.copyFrom(in1);
15446     // in1 = "in", flattened 4-vectors
15447     public result_int reduce_my_ushort4_13(short[] in1) {
15448         // Verify that "in1" is non-null.
15449         if (in1 == null) {
15450             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15453         if (in1.length % 4 != 0) {
15454             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15456         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15458         ain1.copyFrom(in1);
15483     // in1 = "in", flattened 4-vectors
15484     public result_int reduce_my_ushort4_14(short[] in1) {
15485         // Verify that "in1" is non-null.
15486         if (in1 == null) {
15487             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15490         if (in1.length % 4 != 0) {
15491             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15493         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15495         ain1.copyFrom(in1);
15520     // in1 = "in", flattened 4-vectors
15521     public result_int reduce_my_ushort4_15(short[] in1) {
15522         // Verify that "in1" is non-null.
15523         if (in1 == null) {
15524             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15527         if (in1.length % 4 != 0) {
15528             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
15530         Allocation ain1 = Allocation.createSized(mRSLocal, __U16_4, in1.length / 4);
15532         ain1.copyFrom(in1);
15557     // in1 = "in"
15558     public result_int reduce_my_uint_0(int[] in1) {
15559         // Verify that "in1" is non-null.
15560         if (in1 == null) {
15561             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15563         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15565         ain1.copyFrom(in1);
15590     // in1 = "in"
15591     public result_int reduce_my_uint_1(int[] in1) {
15592         // Verify that "in1" is non-null.
15593         if (in1 == null) {
15594             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15596         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15598         ain1.copyFrom(in1);
15623     // in1 = "in"
15624     public result_int reduce_my_uint_2(int[] in1) {
15625         // Verify that "in1" is non-null.
15626         if (in1 == null) {
15627             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15629         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15631         ain1.copyFrom(in1);
15656     // in1 = "in"
15657     public result_int reduce_my_uint_3(int[] in1) {
15658         // Verify that "in1" is non-null.
15659         if (in1 == null) {
15660             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15662         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15664         ain1.copyFrom(in1);
15689     // in1 = "in"
15690     public result_int reduce_my_uint_4(int[] in1) {
15691         // Verify that "in1" is non-null.
15692         if (in1 == null) {
15693             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15695         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15697         ain1.copyFrom(in1);
15722     // in1 = "in"
15723     public result_int reduce_my_uint_5(int[] in1) {
15724         // Verify that "in1" is non-null.
15725         if (in1 == null) {
15726             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15728         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15730         ain1.copyFrom(in1);
15755     // in1 = "in"
15756     public result_int reduce_my_uint_6(int[] in1) {
15757         // Verify that "in1" is non-null.
15758         if (in1 == null) {
15759             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15761         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15763         ain1.copyFrom(in1);
15788     // in1 = "in"
15789     public result_int reduce_my_uint_7(int[] in1) {
15790         // Verify that "in1" is non-null.
15791         if (in1 == null) {
15792             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15794         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15796         ain1.copyFrom(in1);
15821     // in1 = "in"
15822     public result_int reduce_my_uint_8(int[] in1) {
15823         // Verify that "in1" is non-null.
15824         if (in1 == null) {
15825             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15827         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15829         ain1.copyFrom(in1);
15854     // in1 = "in"
15855     public result_int reduce_my_uint_9(int[] in1) {
15856         // Verify that "in1" is non-null.
15857         if (in1 == null) {
15858             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15860         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15862         ain1.copyFrom(in1);
15887     // in1 = "in"
15888     public result_int reduce_my_uint_10(int[] in1) {
15889         // Verify that "in1" is non-null.
15890         if (in1 == null) {
15891             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15893         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15895         ain1.copyFrom(in1);
15920     // in1 = "in"
15921     public result_int reduce_my_uint_11(int[] in1) {
15922         // Verify that "in1" is non-null.
15923         if (in1 == null) {
15924             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15926         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15928         ain1.copyFrom(in1);
15953     // in1 = "in"
15954     public result_int reduce_my_uint_12(int[] in1) {
15955         // Verify that "in1" is non-null.
15956         if (in1 == null) {
15957             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15959         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15961         ain1.copyFrom(in1);
15986     // in1 = "in"
15987     public result_int reduce_my_uint_13(int[] in1) {
15988         // Verify that "in1" is non-null.
15989         if (in1 == null) {
15990             throw new RSIllegalArgumentException("Array \"in1\" is null!");
15992         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
15994         ain1.copyFrom(in1);
16019     // in1 = "in"
16020     public result_int reduce_my_uint_14(int[] in1) {
16021         // Verify that "in1" is non-null.
16022         if (in1 == null) {
16023             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16025         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
16027         ain1.copyFrom(in1);
16052     // in1 = "in"
16053     public result_int reduce_my_uint_15(int[] in1) {
16054         // Verify that "in1" is non-null.
16055         if (in1 == null) {
16056             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16058         Allocation ain1 = Allocation.createSized(mRSLocal, __U32, in1.length);
16060         ain1.copyFrom(in1);
16085     // in1 = "in", flattened 2-vectors
16086     public result_int reduce_my_uint2_0(int[] in1) {
16087         // Verify that "in1" is non-null.
16088         if (in1 == null) {
16089             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16092         if (in1.length % 2 != 0) {
16093             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16095         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16097         ain1.copyFrom(in1);
16122     // in1 = "in", flattened 2-vectors
16123     public result_int reduce_my_uint2_1(int[] in1) {
16124         // Verify that "in1" is non-null.
16125         if (in1 == null) {
16126             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16129         if (in1.length % 2 != 0) {
16130             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16132         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16134         ain1.copyFrom(in1);
16159     // in1 = "in", flattened 2-vectors
16160     public result_int reduce_my_uint2_2(int[] in1) {
16161         // Verify that "in1" is non-null.
16162         if (in1 == null) {
16163             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16166         if (in1.length % 2 != 0) {
16167             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16169         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16171         ain1.copyFrom(in1);
16196     // in1 = "in", flattened 2-vectors
16197     public result_int reduce_my_uint2_3(int[] in1) {
16198         // Verify that "in1" is non-null.
16199         if (in1 == null) {
16200             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16203         if (in1.length % 2 != 0) {
16204             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16206         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16208         ain1.copyFrom(in1);
16233     // in1 = "in", flattened 2-vectors
16234     public result_int reduce_my_uint2_4(int[] in1) {
16235         // Verify that "in1" is non-null.
16236         if (in1 == null) {
16237             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16240         if (in1.length % 2 != 0) {
16241             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16243         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16245         ain1.copyFrom(in1);
16270     // in1 = "in", flattened 2-vectors
16271     public result_int reduce_my_uint2_5(int[] in1) {
16272         // Verify that "in1" is non-null.
16273         if (in1 == null) {
16274             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16277         if (in1.length % 2 != 0) {
16278             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16280         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16282         ain1.copyFrom(in1);
16307     // in1 = "in", flattened 2-vectors
16308     public result_int reduce_my_uint2_6(int[] in1) {
16309         // Verify that "in1" is non-null.
16310         if (in1 == null) {
16311             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16314         if (in1.length % 2 != 0) {
16315             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16317         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16319         ain1.copyFrom(in1);
16344     // in1 = "in", flattened 2-vectors
16345     public result_int reduce_my_uint2_7(int[] in1) {
16346         // Verify that "in1" is non-null.
16347         if (in1 == null) {
16348             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16351         if (in1.length % 2 != 0) {
16352             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16354         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16356         ain1.copyFrom(in1);
16381     // in1 = "in", flattened 2-vectors
16382     public result_int reduce_my_uint2_8(int[] in1) {
16383         // Verify that "in1" is non-null.
16384         if (in1 == null) {
16385             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16388         if (in1.length % 2 != 0) {
16389             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16391         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16393         ain1.copyFrom(in1);
16418     // in1 = "in", flattened 2-vectors
16419     public result_int reduce_my_uint2_9(int[] in1) {
16420         // Verify that "in1" is non-null.
16421         if (in1 == null) {
16422             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16425         if (in1.length % 2 != 0) {
16426             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16428         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16430         ain1.copyFrom(in1);
16455     // in1 = "in", flattened 2-vectors
16456     public result_int reduce_my_uint2_10(int[] in1) {
16457         // Verify that "in1" is non-null.
16458         if (in1 == null) {
16459             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16462         if (in1.length % 2 != 0) {
16463             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16465         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16467         ain1.copyFrom(in1);
16492     // in1 = "in", flattened 2-vectors
16493     public result_int reduce_my_uint2_11(int[] in1) {
16494         // Verify that "in1" is non-null.
16495         if (in1 == null) {
16496             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16499         if (in1.length % 2 != 0) {
16500             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16502         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16504         ain1.copyFrom(in1);
16529     // in1 = "in", flattened 2-vectors
16530     public result_int reduce_my_uint2_12(int[] in1) {
16531         // Verify that "in1" is non-null.
16532         if (in1 == null) {
16533             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16536         if (in1.length % 2 != 0) {
16537             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16539         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16541         ain1.copyFrom(in1);
16566     // in1 = "in", flattened 2-vectors
16567     public result_int reduce_my_uint2_13(int[] in1) {
16568         // Verify that "in1" is non-null.
16569         if (in1 == null) {
16570             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16573         if (in1.length % 2 != 0) {
16574             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16576         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16578         ain1.copyFrom(in1);
16603     // in1 = "in", flattened 2-vectors
16604     public result_int reduce_my_uint2_14(int[] in1) {
16605         // Verify that "in1" is non-null.
16606         if (in1 == null) {
16607             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16610         if (in1.length % 2 != 0) {
16611             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16613         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16615         ain1.copyFrom(in1);
16640     // in1 = "in", flattened 2-vectors
16641     public result_int reduce_my_uint2_15(int[] in1) {
16642         // Verify that "in1" is non-null.
16643         if (in1 == null) {
16644             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16647         if (in1.length % 2 != 0) {
16648             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
16650         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_2, in1.length / 2);
16652         ain1.copyFrom(in1);
16677     // in1 = "in", flattened 4-vectors
16678     public result_int reduce_my_uint4_0(int[] in1) {
16679         // Verify that "in1" is non-null.
16680         if (in1 == null) {
16681             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16684         if (in1.length % 4 != 0) {
16685             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16687         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16689         ain1.copyFrom(in1);
16714     // in1 = "in", flattened 4-vectors
16715     public result_int reduce_my_uint4_1(int[] in1) {
16716         // Verify that "in1" is non-null.
16717         if (in1 == null) {
16718             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16721         if (in1.length % 4 != 0) {
16722             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16724         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16726         ain1.copyFrom(in1);
16751     // in1 = "in", flattened 4-vectors
16752     public result_int reduce_my_uint4_2(int[] in1) {
16753         // Verify that "in1" is non-null.
16754         if (in1 == null) {
16755             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16758         if (in1.length % 4 != 0) {
16759             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16761         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16763         ain1.copyFrom(in1);
16788     // in1 = "in", flattened 4-vectors
16789     public result_int reduce_my_uint4_3(int[] in1) {
16790         // Verify that "in1" is non-null.
16791         if (in1 == null) {
16792             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16795         if (in1.length % 4 != 0) {
16796             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16798         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16800         ain1.copyFrom(in1);
16825     // in1 = "in", flattened 4-vectors
16826     public result_int reduce_my_uint4_4(int[] in1) {
16827         // Verify that "in1" is non-null.
16828         if (in1 == null) {
16829             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16832         if (in1.length % 4 != 0) {
16833             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16835         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16837         ain1.copyFrom(in1);
16862     // in1 = "in", flattened 4-vectors
16863     public result_int reduce_my_uint4_5(int[] in1) {
16864         // Verify that "in1" is non-null.
16865         if (in1 == null) {
16866             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16869         if (in1.length % 4 != 0) {
16870             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16872         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16874         ain1.copyFrom(in1);
16899     // in1 = "in", flattened 4-vectors
16900     public result_int reduce_my_uint4_6(int[] in1) {
16901         // Verify that "in1" is non-null.
16902         if (in1 == null) {
16903             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16906         if (in1.length % 4 != 0) {
16907             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16909         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16911         ain1.copyFrom(in1);
16936     // in1 = "in", flattened 4-vectors
16937     public result_int reduce_my_uint4_7(int[] in1) {
16938         // Verify that "in1" is non-null.
16939         if (in1 == null) {
16940             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16943         if (in1.length % 4 != 0) {
16944             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16946         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16948         ain1.copyFrom(in1);
16973     // in1 = "in", flattened 4-vectors
16974     public result_int reduce_my_uint4_8(int[] in1) {
16975         // Verify that "in1" is non-null.
16976         if (in1 == null) {
16977             throw new RSIllegalArgumentException("Array \"in1\" is null!");
16980         if (in1.length % 4 != 0) {
16981             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
16983         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
16985         ain1.copyFrom(in1);
17010     // in1 = "in", flattened 4-vectors
17011     public result_int reduce_my_uint4_9(int[] in1) {
17012         // Verify that "in1" is non-null.
17013         if (in1 == null) {
17014             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17017         if (in1.length % 4 != 0) {
17018             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
17020         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
17022         ain1.copyFrom(in1);
17047     // in1 = "in", flattened 4-vectors
17048     public result_int reduce_my_uint4_10(int[] in1) {
17049         // Verify that "in1" is non-null.
17050         if (in1 == null) {
17051             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17054         if (in1.length % 4 != 0) {
17055             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
17057         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
17059         ain1.copyFrom(in1);
17084     // in1 = "in", flattened 4-vectors
17085     public result_int reduce_my_uint4_11(int[] in1) {
17086         // Verify that "in1" is non-null.
17087         if (in1 == null) {
17088             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17091         if (in1.length % 4 != 0) {
17092             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
17094         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
17096         ain1.copyFrom(in1);
17121     // in1 = "in", flattened 4-vectors
17122     public result_int reduce_my_uint4_12(int[] in1) {
17123         // Verify that "in1" is non-null.
17124         if (in1 == null) {
17125             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17128         if (in1.length % 4 != 0) {
17129             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
17131         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
17133         ain1.copyFrom(in1);
17158     // in1 = "in", flattened 4-vectors
17159     public result_int reduce_my_uint4_13(int[] in1) {
17160         // Verify that "in1" is non-null.
17161         if (in1 == null) {
17162             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17165         if (in1.length % 4 != 0) {
17166             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
17168         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
17170         ain1.copyFrom(in1);
17195     // in1 = "in", flattened 4-vectors
17196     public result_int reduce_my_uint4_14(int[] in1) {
17197         // Verify that "in1" is non-null.
17198         if (in1 == null) {
17199             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17202         if (in1.length % 4 != 0) {
17203             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
17205         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
17207         ain1.copyFrom(in1);
17232     // in1 = "in", flattened 4-vectors
17233     public result_int reduce_my_uint4_15(int[] in1) {
17234         // Verify that "in1" is non-null.
17235         if (in1 == null) {
17236             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17239         if (in1.length % 4 != 0) {
17240             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
17242         Allocation ain1 = Allocation.createSized(mRSLocal, __U32_4, in1.length / 4);
17244         ain1.copyFrom(in1);
17269     // in1 = "in"
17270     public result_int reduce_my_ulong_0(long[] in1) {
17271         // Verify that "in1" is non-null.
17272         if (in1 == null) {
17273             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17275         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17277         ain1.copyFrom(in1);
17302     // in1 = "in"
17303     public result_int reduce_my_ulong_1(long[] in1) {
17304         // Verify that "in1" is non-null.
17305         if (in1 == null) {
17306             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17308         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17310         ain1.copyFrom(in1);
17335     // in1 = "in"
17336     public result_int reduce_my_ulong_2(long[] in1) {
17337         // Verify that "in1" is non-null.
17338 in1 == null) {
17339             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17341         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17343         ain1.copyFrom(in1);
17368     // in1 = "in"
17369     public result_int reduce_my_ulong_3(long[] in1) {
17370         // Verify that "in1" is non-null.
17371         if (in1 == null) {
17372             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17374         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17376         ain1.copyFrom(in1);
17401     // in1 = "in"
17402     public result_int reduce_my_ulong_4(long[] in1) {
17403         // Verify that "in1" is non-null.
17404         if (in1 == null) {
17405             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17407         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17409         ain1.copyFrom(in1);
17434     // in1 = "in"
17435     public result_int reduce_my_ulong_5(long[] in1) {
17436         // Verify that "in1" is non-null.
17437         if (in1 == null) {
17438             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17440         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17442         ain1.copyFrom(in1);
17467     // in1 = "in"
17468     public result_int reduce_my_ulong_6(long[] in1) {
17469         // Verify that "in1" is non-null.
17470         if (in1 == null) {
17471             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17473         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17475         ain1.copyFrom(in1);
17500     // in1 = "in"
17501     public result_int reduce_my_ulong_7(long[] in1) {
17502         // Verify that "in1" is non-null.
17503         if (in1 == null) {
17504             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17506         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17508         ain1.copyFrom(in1);
17533     // in1 = "in"
17534     public result_int reduce_my_ulong_8(long[] in1) {
17535         // Verify that "in1" is non-null.
17536         if (in1 == null) {
17537             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17539         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17541         ain1.copyFrom(in1);
17566     // in1 = "in"
17567     public result_int reduce_my_ulong_9(long[] in1) {
17568         // Verify that "in1" is non-null.
17569         if (in1 == null) {
17570             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17572         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17574         ain1.copyFrom(in1);
17599     // in1 = "in"
17600     public result_int reduce_my_ulong_10(long[] in1) {
17601         // Verify that "in1" is non-null.
17602         if (in1 == null) {
17603             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17605         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17607         ain1.copyFrom(in1);
17632     // in1 = "in"
17633     public result_int reduce_my_ulong_11(long[] in1) {
17634         // Verify that "in1" is non-null.
17635         if (in1 == null) {
17636             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17638         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17640         ain1.copyFrom(in1);
17665     // in1 = "in"
17666     public result_int reduce_my_ulong_12(long[] in1) {
17667         // Verify that "in1" is non-null.
17668         if (in1 == null) {
17669             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17671         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17673         ain1.copyFrom(in1);
17698     // in1 = "in"
17699     public result_int reduce_my_ulong_13(long[] in1) {
17700         // Verify that "in1" is non-null.
17701         if (in1 == null) {
17702             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17704         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17706         ain1.copyFrom(in1);
17731     // in1 = "in"
17732     public result_int reduce_my_ulong_14(long[] in1) {
17733         // Verify that "in1" is non-null.
17734         if (in1 == null) {
17735             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17737         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17739         ain1.copyFrom(in1);
17764     // in1 = "in"
17765     public result_int reduce_my_ulong_15(long[] in1) {
17766         // Verify that "in1" is non-null.
17767         if (in1 == null) {
17768             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17770         Allocation ain1 = Allocation.createSized(mRSLocal, __U64, in1.length);
17772         ain1.copyFrom(in1);
17797     // in1 = "in", flattened 2-vectors
17798     public result_int reduce_my_ulong2_0(long[] in1) {
17799         // Verify that "in1" is non-null.
17800         if (in1 == null) {
17801             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17804         if (in1.length % 2 != 0) {
17805             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
17807         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
17809         ain1.copyFrom(in1);
17834     // in1 = "in", flattened 2-vectors
17835     public result_int reduce_my_ulong2_1(long[] in1) {
17836         // Verify that "in1" is non-null.
17837         if (in1 == null) {
17838             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17841         if (in1.length % 2 != 0) {
17842             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
17844         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
17846         ain1.copyFrom(in1);
17871     // in1 = "in", flattened 2-vectors
17872     public result_int reduce_my_ulong2_2(long[] in1) {
17873         // Verify that "in1" is non-null.
17874         if (in1 == null) {
17875             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17878         if (in1.length % 2 != 0) {
17879             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
17881         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
17883         ain1.copyFrom(in1);
17908     // in1 = "in", flattened 2-vectors
17909     public result_int reduce_my_ulong2_3(long[] in1) {
17910         // Verify that "in1" is non-null.
17911         if (in1 == null) {
17912             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17915         if (in1.length % 2 != 0) {
17916             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
17918         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
17920         ain1.copyFrom(in1);
17945     // in1 = "in", flattened 2-vectors
17946     public result_int reduce_my_ulong2_4(long[] in1) {
17947         // Verify that "in1" is non-null.
17948         if (in1 == null) {
17949             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17952         if (in1.length % 2 != 0) {
17953             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
17955         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
17957         ain1.copyFrom(in1);
17982     // in1 = "in", flattened 2-vectors
17983     public result_int reduce_my_ulong2_5(long[] in1) {
17984         // Verify that "in1" is non-null.
17985         if (in1 == null) {
17986             throw new RSIllegalArgumentException("Array \"in1\" is null!");
17989         if (in1.length % 2 != 0) {
17990             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
17992         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
17994         ain1.copyFrom(in1);
18019     // in1 = "in", flattened 2-vectors
18020     public result_int reduce_my_ulong2_6(long[] in1) {
18021         // Verify that "in1" is non-null.
18022         if (in1 == null) {
18023             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18026         if (in1.length % 2 != 0) {
18027             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18029         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18031         ain1.copyFrom(in1);
18056     // in1 = "in", flattened 2-vectors
18057     public result_int reduce_my_ulong2_7(long[] in1) {
18058         // Verify that "in1" is non-null.
18059         if (in1 == null) {
18060             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18063         if (in1.length % 2 != 0) {
18064             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18066         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18068         ain1.copyFrom(in1);
18093     // in1 = "in", flattened 2-vectors
18094     public result_int reduce_my_ulong2_8(long[] in1) {
18095         // Verify that "in1" is non-null.
18096         if (in1 == null) {
18097             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18100         if (in1.length % 2 != 0) {
18101             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18103         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18105         ain1.copyFrom(in1);
18130     // in1 = "in", flattened 2-vectors
18131     public result_int reduce_my_ulong2_9(long[] in1) {
18132         // Verify that "in1" is non-null.
18133         if (in1 == null) {
18134             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18137         if (in1.length % 2 != 0) {
18138             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18140         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18142         ain1.copyFrom(in1);
18167     // in1 = "in", flattened 2-vectors
18168     public result_int reduce_my_ulong2_10(long[] in1) {
18169         // Verify that "in1" is non-null.
18170         if (in1 == null) {
18171             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18174         if (in1.length % 2 != 0) {
18175             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18177         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18179         ain1.copyFrom(in1);
18204     // in1 = "in", flattened 2-vectors
18205     public result_int reduce_my_ulong2_11(long[] in1) {
18206         // Verify that "in1" is non-null.
18207         if (in1 == null) {
18208             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18211         if (in1.length % 2 != 0) {
18212             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18214         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18216         ain1.copyFrom(in1);
18241     // in1 = "in", flattened 2-vectors
18242     public result_int reduce_my_ulong2_12(long[] in1) {
18243         // Verify that "in1" is non-null.
18244         if (in1 == null) {
18245             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18248         if (in1.length % 2 != 0) {
18249             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18251         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18253         ain1.copyFrom(in1);
18278     // in1 = "in", flattened 2-vectors
18279     public result_int reduce_my_ulong2_13(long[] in1) {
18280         // Verify that "in1" is non-null.
18281         if (in1 == null) {
18282             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18285         if (in1.length % 2 != 0) {
18286             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18288         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18290         ain1.copyFrom(in1);
18315     // in1 = "in", flattened 2-vectors
18316     public result_int reduce_my_ulong2_14(long[] in1) {
18317         // Verify that "in1" is non-null.
18318         if (in1 == null) {
18319             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18322         if (in1.length % 2 != 0) {
18323             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18325         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18327         ain1.copyFrom(in1);
18352     // in1 = "in", flattened 2-vectors
18353     public result_int reduce_my_ulong2_15(long[] in1) {
18354         // Verify that "in1" is non-null.
18355         if (in1 == null) {
18356             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18359         if (in1.length % 2 != 0) {
18360             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 2 in length!");
18362         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_2, in1.length / 2);
18364         ain1.copyFrom(in1);
18389     // in1 = "in", flattened 4-vectors
18390     public result_int reduce_my_ulong4_0(long[] in1) {
18391         // Verify that "in1" is non-null.
18392         if (in1 == null) {
18393             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18396         if (in1.length % 4 != 0) {
18397             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18399         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18401         ain1.copyFrom(in1);
18426     // in1 = "in", flattened 4-vectors
18427     public result_int reduce_my_ulong4_1(long[] in1) {
18428         // Verify that "in1" is non-null.
18429         if (in1 == null) {
18430             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18433         if (in1.length % 4 != 0) {
18434             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18436         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18438         ain1.copyFrom(in1);
18463     // in1 = "in", flattened 4-vectors
18464     public result_int reduce_my_ulong4_2(long[] in1) {
18465         // Verify that "in1" is non-null.
18466         if (in1 == null) {
18467             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18470         if (in1.length % 4 != 0) {
18471             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18473         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18475         ain1.copyFrom(in1);
18500     // in1 = "in", flattened 4-vectors
18501     public result_int reduce_my_ulong4_3(long[] in1) {
18502         // Verify that "in1" is non-null.
18503         if (in1 == null) {
18504             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18507         if (in1.length % 4 != 0) {
18508             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18510         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18512         ain1.copyFrom(in1);
18537     // in1 = "in", flattened 4-vectors
18538     public result_int reduce_my_ulong4_4(long[] in1) {
18539         // Verify that "in1" is non-null.
18540         if (in1 == null) {
18541             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18544         if (in1.length % 4 != 0) {
18545             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18547         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18549         ain1.copyFrom(in1);
18574     // in1 = "in", flattened 4-vectors
18575     public result_int reduce_my_ulong4_5(long[] in1) {
18576         // Verify that "in1" is non-null.
18577         if (in1 == null) {
18578             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18581         if (in1.length % 4 != 0) {
18582             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18584         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18586         ain1.copyFrom(in1);
18611     // in1 = "in", flattened 4-vectors
18612     public result_int reduce_my_ulong4_6(long[] in1) {
18613         // Verify that "in1" is non-null.
18614         if (in1 == null) {
18615             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18618         if (in1.length % 4 != 0) {
18619             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18621         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18623         ain1.copyFrom(in1);
18648     // in1 = "in", flattened 4-vectors
18649     public result_int reduce_my_ulong4_7(long[] in1) {
18650         // Verify that "in1" is non-null.
18651         if (in1 == null) {
18652             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18655         if (in1.length % 4 != 0) {
18656             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18658         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18660         ain1.copyFrom(in1);
18685     // in1 = "in", flattened 4-vectors
18686     public result_int reduce_my_ulong4_8(long[] in1) {
18687         // Verify that "in1" is non-null.
18688         if (in1 == null) {
18689             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18692         if (in1.length % 4 != 0) {
18693             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18695         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18697         ain1.copyFrom(in1);
18722     // in1 = "in", flattened 4-vectors
18723     public result_int reduce_my_ulong4_9(long[] in1) {
18724         // Verify that "in1" is non-null.
18725         if (in1 == null) {
18726             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18729         if (in1.length % 4 != 0) {
18730             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18732         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18734         ain1.copyFrom(in1);
18759     // in1 = "in", flattened 4-vectors
18760     public result_int reduce_my_ulong4_10(long[] in1) {
18761         // Verify that "in1" is non-null.
18762         if (in1 == null) {
18763             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18766         if (in1.length % 4 != 0) {
18767             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18769         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18771         ain1.copyFrom(in1);
18796     // in1 = "in", flattened 4-vectors
18797     public result_int reduce_my_ulong4_11(long[] in1) {
18798         // Verify that "in1" is non-null.
18799         if (in1 == null) {
18800             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18803         if (in1.length % 4 != 0) {
18804             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18806         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18808         ain1.copyFrom(in1);
18833     // in1 = "in", flattened 4-vectors
18834     public result_int reduce_my_ulong4_12(long[] in1) {
18835         // Verify that "in1" is non-null.
18836         if (in1 == null) {
18837             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18840         if (in1.length % 4 != 0) {
18841             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18843         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18845         ain1.copyFrom(in1);
18870     // in1 = "in", flattened 4-vectors
18871     public result_int reduce_my_ulong4_13(long[] in1) {
18872         // Verify that "in1" is non-null.
18873         if (in1 == null) {
18874             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18877         if (in1.length % 4 != 0) {
18878             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18880         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18882         ain1.copyFrom(in1);
18907     // in1 = "in", flattened 4-vectors
18908     public result_int reduce_my_ulong4_14(long[] in1) {
18909         // Verify that "in1" is non-null.
18910         if (in1 == null) {
18911             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18914         if (in1.length % 4 != 0) {
18915             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18917         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18919         ain1.copyFrom(in1);
18944     // in1 = "in", flattened 4-vectors
18945     public result_int reduce_my_ulong4_15(long[] in1) {
18946         // Verify that "in1" is non-null.
18947         if (in1 == null) {
18948             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18951         if (in1.length % 4 != 0) {
18952             throw new RSIllegalArgumentException("Array \"in1\" is not a multiple of 4 in length!");
18954         Allocation ain1 = Allocation.createSized(mRSLocal, __U64_4, in1.length / 4);
18956         ain1.copyFrom(in1);
18981     // in1 = "in"
18982     public result_int reduce_my_bool_0(byte[] in1) {
18983         // Verify that "in1" is non-null.
18984         if (in1 == null) {
18985             throw new RSIllegalArgumentException("Array \"in1\" is null!");
18987         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
18989         ain1.copyFrom(in1);
19014     // in1 = "in"
19015     public result_int reduce_my_bool_1(byte[] in1) {
19016         // Verify that "in1" is non-null.
19017         if (in1 == null) {
19018             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19020 in1.length);
19022         ain1.copyFrom(in1);
19047     // in1 = "in"
19048     public result_int reduce_my_bool_2(byte[] in1) {
19049         // Verify that "in1" is non-null.
19050         if (in1 == null) {
19051             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19053         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19055         ain1.copyFrom(in1);
19080     // in1 = "in"
19081     public result_int reduce_my_bool_3(byte[] in1) {
19082         // Verify that "in1" is non-null.
19083         if (in1 == null) {
19084             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19086         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19088         ain1.copyFrom(in1);
19113     // in1 = "in"
19114     public result_int reduce_my_bool_4(byte[] in1) {
19115         // Verify that "in1" is non-null.
19116         if (in1 == null) {
19117             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19119         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19121         ain1.copyFrom(in1);
19146     // in1 = "in"
19147     public result_int reduce_my_bool_5(byte[] in1) {
19148         // Verify that "in1" is non-null.
19149         if (in1 == null) {
19150             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19152         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19154         ain1.copyFrom(in1);
19179     // in1 = "in"
19180     public result_int reduce_my_bool_6(byte[] in1) {
19181         // Verify that "in1" is non-null.
19182         if (in1 == null) {
19183             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19185         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19187         ain1.copyFrom(in1);
19212     // in1 = "in"
19213     public result_int reduce_my_bool_7(byte[] in1) {
19214         // Verify that "in1" is non-null.
19215         if (in1 == null) {
19216             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19218         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19220         ain1.copyFrom(in1);
19245     // in1 = "in"
19246     public result_int reduce_my_bool_8(byte[] in1) {
19247         // Verify that "in1" is non-null.
19248         if (in1 == null) {
19249             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19251         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19253         ain1.copyFrom(in1);
19278     // in1 = "in"
19279     public result_int reduce_my_bool_9(byte[] in1) {
19280         // Verify that "in1" is non-null.
19281         if (in1 == null) {
19282             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19284         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19286         ain1.copyFrom(in1);
19311     // in1 = "in"
19312     public result_int reduce_my_bool_10(byte[] in1) {
19313         // Verify that "in1" is non-null.
19314         if (in1 == null) {
19315             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19317         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19319         ain1.copyFrom(in1);
19344     // in1 = "in"
19345     public result_int reduce_my_bool_11(byte[] in1) {
19346         // Verify that "in1" is non-null.
19347         if (in1 == null) {
19348             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19350         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19352         ain1.copyFrom(in1);
19377     // in1 = "in"
19378     public result_int reduce_my_bool_12(byte[] in1) {
19379         // Verify that "in1" is non-null.
19380         if (in1 == null) {
19381             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19383         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19385         ain1.copyFrom(in1);
19410     // in1 = "in"
19411     public result_int reduce_my_bool_13(byte[] in1) {
19412         // Verify that "in1" is non-null.
19413         if (in1 == null) {
19414             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19416         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19418         ain1.copyFrom(in1);
19443     // in1 = "in"
19444     public result_int reduce_my_bool_14(byte[] in1) {
19445         // Verify that "in1" is non-null.
19446         if (in1 == null) {
19447             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19449         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19451         ain1.copyFrom(in1);
19476     // in1 = "in"
19477     public result_int reduce_my_bool_15(byte[] in1) {
19478         // Verify that "in1" is non-null.
19479         if (in1 == null) {
19480             throw new RSIllegalArgumentException("Array \"in1\" is null!");
19482         Allocation ain1 = Allocation.createSized(mRSLocal, __BOOLEAN, in1.length);
19484         ain1.copyFrom(in1);
OpenGrok
